diff --git a/system/libraries/Email.php b/system/libraries/Email.php
index 4cd9308..9c51211 100644
--- a/system/libraries/Email.php
+++ b/system/libraries/Email.php
@@ -1,1815 +1 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
-/**
- * CodeIgniter
- *
- * An open source application development framework for PHP 4.3.2 or newer
- *
- * @package		CodeIgniter
- * @author		Rick Ellis
- * @copyright	Copyright (c) 2006, EllisLab, Inc.
- * @license		http://www.codeigniter.com/user_guide/license.html
- * @link		http://www.codeigniter.com
- * @since		Version 1.0
- * @filesource
- */
-
-// ------------------------------------------------------------------------
-
-/**
- * CodeIgniter Email Class
- *
- * Permits email to be sent using Mail, Sendmail, or SMTP.
- *
- * @package		CodeIgniter
- * @subpackage	Libraries
- * @category	Libraries
- * @author		Rick Ellis
- * @link		http://www.codeigniter.com/user_guide/libraries/email.html
- */
-class CI_Email {
-
-	var	$useragent		= "CodeIgniter";
-	var	$mailpath		= "/usr/sbin/sendmail";	// Sendmail path
-	var	$protocol		= "mail";	// mail/sendmail/smtp
-	var	$smtp_host		= "";		// SMTP Server.  Example: mail.earthlink.net
-	var	$smtp_user		= "";		// SMTP Username
-	var	$smtp_pass		= "";		// SMTP Password
-	var	$smtp_port		= "25";		// SMTP Port
-	var	$smtp_timeout	= 5;		// SMTP Timeout in seconds
-	var	$wordwrap		= TRUE;		// true/false  Turns word-wrap on/off
-	var	$wrapchars		= "76";		// Number of characters to wrap at.
-	var	$mailtype		= "text";	// text/html  Defines email formatting
-	var	$charset		= "utf-8";	// Default char set: iso-8859-1 or us-ascii
-	var	$multipart		= "mixed";	// "mixed" (in the body) or "related" (separate)
-	var $alt_message	= '';		// Alternative message for HTML emails
-	var	$validate		= FALSE;	// true/false.  Enables email validation
-	var	$priority		= "3";		// Default priority (1 - 5)
-	var	$newline		= "\n";		// Default newline. "\r\n" or "\n" (Use "\r\n" to comply with RFC 822)
-
-	var $crlf			= "\n";		// The RFC 2045 compliant CRLF for quoted-printable is "\r\n".  Apparently some servers,
-									// even on the receiving end think they need to muck with CRLFs, so using "\n", while
-									// distasteful, is the only thing that seems to work for all environments.
-
-	var	$bcc_batch_mode	= FALSE;	// true/false  Turns on/off Bcc batch feature
-	var	$bcc_batch_size	= 200;		// If bcc_batch_mode = true, sets max number of Bccs in each batch
-	var	$_subject		= "";
-	var	$_body			= "";
-	var	$_finalbody		= "";
-	var	$_alt_boundary	= "";
-	var	$_atc_boundary	= "";
-	var	$_header_str	= "";
-	var	$_smtp_connect	= "";
-	var	$_encoding		= "8bit";
-	var $_safe_mode		= FALSE;
-	var $_IP			= FALSE;
-	var	$_smtp_auth		= FALSE;
-	var $_replyto_flag	= FALSE;
-	var	$_debug_msg		= array();
-	var	$_recipients	= array();
-	var	$_cc_array		= array();
-	var	$_bcc_array		= array();
-	var	$_headers		= array();
-	var	$_attach_name	= array();
-	var	$_attach_type	= array();
-	var	$_attach_disp	= array();
-	var	$_protocols		= array('mail', 'sendmail', 'smtp');
-	var	$_base_charsets	= array('iso-8859-1', 'us-ascii');
-	var	$_bit_depths	= array('7bit', '8bit');
-	var	$_priorities	= array('1 (Highest)', '2 (High)', '3 (Normal)', '4 (Low)', '5 (Lowest)');	
-
-
-	/**
-	 * Constructor - Sets Email Preferences
-	 *
-	 * The constructor can be passed an array of config values
-	 */	
-	function CI_Email($config = array())
-	{		
-		if (count($config) > 0)
-		{
-			$this->initialize($config);
-		}	
-
-		log_message('debug', "Email Class Initialized");
-	}
-
-	// --------------------------------------------------------------------
-
-	/**
-	 * Initialize preferences
-	 *
-	 * @access	public
-	 * @param	array
-	 * @return	void
-	 */	
-	function initialize($config = array())
-	{
-		$this->clear();
-		foreach ($config as $key => $val)
-		{
-			if (isset($this->$key))
-			{
-				$method = 'set_'.$key;
-				
-				if (method_exists($this, $method))
-				{
-					$this->$method($val);
-				}
-				else
-				{
-					$this->$key = $val;
-				}			
-			}
-		}
-		$this->_smtp_auth = ($this->smtp_user == '' AND $this->smtp_pass == '') ? FALSE : TRUE;			
-		$this->_safe_mode = (@ini_get("safe_mode") == 0) ? FALSE : TRUE;
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Initialize the Email Data
-	 *
-	 * @access	public
-	 * @return	void
-	 */	
-	function clear($clear_attachments = FALSE)
-	{
-		$this->_subject		= "";
-		$this->_body		= "";
-		$this->_finalbody	= "";
-		$this->_header_str	= "";
-		$this->_replyto_flag = FALSE;
-		$this->_recipients	= array();
-		$this->_headers		= array();
-		$this->_debug_msg	= array();
-		
-		$this->_set_header('User-Agent', $this->useragent);				
-		$this->_set_header('Date', $this->_set_date());
-		
-		if ($clear_attachments !== FALSE)
-		{
-			$this->_attach_name = array();
-			$this->_attach_type = array();
-			$this->_attach_disp = array();
-		}   		
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Set FROM
-	 *
-	 * @access	public
-	 * @param	string
-	 * @param	string
-	 * @return	void
-	 */	
-	function from($from, $name = '')
-	{
-		if (preg_match( '/\<(.*)\>/', $from, $match))
-			$from = $match['1'];
-
-		if ($this->validate)
-			$this->validate_email($this->_str_to_array($from));
-			
-		if ($name != '' && substr($name, 0, 1) != '"')
-		{
-			$name = '"'.$name.'"';
-		}
-	
-		$this->_set_header('From', $name.' <'.$from.'>');
-		$this->_set_header('Return-Path', '<'.$from.'>');
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Set Reply-to
-	 *
-	 * @access	public
-	 * @param	string
-	 * @param	string
-	 * @return	void
-	 */	
-	function reply_to($replyto, $name = '')
-	{
-		if (preg_match( '/\<(.*)\>/', $replyto, $match))
-			$replyto = $match['1'];
-
-		if ($this->validate)
-			$this->validate_email($this->_str_to_array($replyto));	
-
-		if ($name == '')
-		{
-			$name = $replyto;
-		}
-
-		if (substr($name, 0, 1) != '"')
-		{
-			$name = '"'.$name.'"';
-		}
-
-		$this->_set_header('Reply-To', $name.' <'.$replyto.'>');
-		$this->_replyto_flag = TRUE;
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Set Recipients
-	 *
-	 * @access	public
-	 * @param	string
-	 * @return	void
-	 */	
-	function to($to)
-	{
-		$to = $this->_str_to_array($to);
-		$to = $this->clean_email($to);
-	
-		if ($this->validate)
-			$this->validate_email($to);
-			
-		if ($this->_get_protocol() != 'mail')
-			$this->_set_header('To', implode(", ", $to));
-
-		switch ($this->_get_protocol())
-		{
-			case 'smtp'		: $this->_recipients = $to;
-			break;
-			case 'sendmail'	: $this->_recipients = implode(", ", $to);
-			break;
-			case 'mail'		: $this->_recipients = implode(", ", $to);
-			break;
-		}	
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Set CC
-	 *
-	 * @access	public
-	 * @param	string
-	 * @return	void
-	 */	
-	function cc($cc)
-	{	
-		$cc = $this->_str_to_array($cc);
-		$cc = $this->clean_email($cc);
-
-		if ($this->validate)
-			$this->validate_email($cc);
-
-		$this->_set_header('Cc', implode(", ", $cc));
-		
-		if ($this->_get_protocol() == "smtp")
-			$this->_cc_array = $cc;
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Set BCC
-	 *
-	 * @access	public
-	 * @param	string
-	 * @param	string
-	 * @return	void
-	 */	
-	function bcc($bcc, $limit = '')
-	{
-		if ($limit != '' && is_numeric($limit))
-		{
-			$this->bcc_batch_mode = true;
-			$this->bcc_batch_size = $limit;
-		}
-
-		$bcc = $this->_str_to_array($bcc);
-		$bcc = $this->clean_email($bcc);
-		
-		if ($this->validate)
-			$this->validate_email($bcc);
-
-		if (($this->_get_protocol() == "smtp") OR ($this->bcc_batch_mode && count($bcc) > $this->bcc_batch_size))
-			$this->_bcc_array = $bcc;
-		else
-			$this->_set_header('Bcc', implode(", ", $bcc));
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Set Email Subject
-	 *
-	 * @access	public
-	 * @param	string
-	 * @return	void
-	 */	
-	function subject($subject)
-	{
-		$subject = preg_replace("/(\r\n)|(\r)|(\n)/", "", $subject);
-		$subject = preg_replace("/(\t)/", " ", $subject);
-		
-		$this->_set_header('Subject', trim($subject));		
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Set Body
-	 *
-	 * @access	public
-	 * @param	string
-	 * @return	void
-	 */	
-	function message($body)
-	{
-		$this->_body = stripslashes(rtrim(str_replace("\r", "", $body)));	
-	}	
- 	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Assign file attachments
-	 *
-	 * @access	public
-	 * @param	string
-	 * @return	string
-	 */		
-	function attach($filename, $disposition = 'attachment')
-	{			
-		$this->_attach_name[] = $filename;
-		$this->_attach_type[] = $this->_mime_types(next(explode('.', basename($filename))));
-		$this->_attach_disp[] = $disposition; // Can also be 'inline'  Not sure if it matters
-	}
-
-	// --------------------------------------------------------------------
-
-	/**
-	 * Add a Header Item
-	 *
-	 * @access	public
-	 * @param	string
-	 * @param	string
-	 * @return	void
-	 */	
-	function _set_header($header, $value)
-	{
-		$this->_headers[$header] = $value;
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Convert a String to an Array
-	 *
-	 * @access	public
-	 * @param	string
-	 * @return	array
-	 */	
-	function _str_to_array($email)
-	{
-		if ( ! is_array($email))
-		{	
-			if (ereg(',$', $email))
-				$email = substr($email, 0, -1);
-			
-			if (ereg('^,', $email))
-				$email = substr($email, 1);	
-					
-			if (ereg(',', $email))
-			{					
-				$x = explode(',', $email);
-				$email = array();
-				
-				for ($i = 0; $i < count($x); $i ++)
-					$email[] = trim($x[$i]);
-			}
-			else
-			{				
-				$email = trim($email);
-				settype($email, "array");
-			}
-		}
-		return $email;
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Set Multipart Value
-	 *
-	 * @access	public
-	 * @param	string
-	 * @return	void
-	 */	
-	function set_alt_message($str = '')
-	{
-		$this->alt_message = ($str == '') ? '' : $str;
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Set Mailtype
-	 *
-	 * @access	public
-	 * @param	string
-	 * @return	void
-	 */	
-	function set_mailtype($type = 'text')
-	{
-		$this->mailtype = ($type == 'html') ? 'html' : 'text';
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Set Wordwrap
-	 *
-	 * @access	public
-	 * @param	string
-	 * @return	void
-	 */	
-	function set_wordwrap($wordwrap = TRUE)
-	{
-		$this->wordwrap = ($wordwrap === FALSE) ? FALSE : TRUE;
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Set Protocol
-	 *
-	 * @access	public
-	 * @param	string
-	 * @return	void
-	 */	
-	function set_protocol($protocol = 'mail')
-	{
-		$this->protocol = ( ! in_array($protocol, $this->_protocols, TRUE)) ? 'mail' : strtolower($protocol);
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Set Priority
-	 *
-	 * @access	public
-	 * @param	integer
-	 * @return	void
-	 */	
-	function set_priority($n = 3)
-	{
-		if ( ! is_numeric($n))
-		{
-			$this->priority = 3;
-			return;
-		}
-	
-		if ($n < 1 OR $n > 5)
-		{
-			$this->priority = 3;
-			return;
-		}
-	
-		$this->priority = $n;
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Set Newline Character
-	 *
-	 * @access	public
-	 * @param	string
-	 * @return	void
-	 */	
-	function set_newline($newline = "\n")
-	{
-		if ($newline != "\n" AND $newline != "\r\n" AND $newline != "\r")
-		{
-			$this->newline	= "\n";	
-			return;
-		}
-	
-		$this->newline	= $newline;	
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Set Message Boundary
-	 *
-	 * @access	private
-	 * @return	void
-	 */	
-	function _set_boundaries()
-	{
-		$this->_alt_boundary = "B_ALT_".uniqid(''); // multipart/alternative
-		$this->_atc_boundary = "B_ATC_".uniqid(''); // attachment boundary
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Get the Message ID
-	 *
-	 * @access	private
-	 * @return	string
-	 */	
-	function _get_message_id()
-	{
-		$from = $this->_headers['Return-Path'];
-		$from = str_replace(">", "", $from);
-		$from = str_replace("<", "", $from);
-	
-		return  "<".uniqid('').strstr($from, '@').">";	
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Get Mail Protocol
-	 *
-	 * @access	private
-	 * @param	bool
-	 * @return	string
-	 */	
-	function _get_protocol($return = true)
-	{
-		$this->protocol = strtolower($this->protocol);
-		$this->protocol = ( ! in_array($this->protocol, $this->_protocols, TRUE)) ? 'mail' : $this->protocol;
-		
-		if ($return == true)
-			return $this->protocol;
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Get Mail Encoding
-	 *
-	 * @access	private
-	 * @param	bool
-	 * @return	string
-	 */	
-	function _get_encoding($return = true)
-	{		
-		$this->_encoding = ( ! in_array($this->_encoding, $this->_bit_depths)) ? '7bit' : $this->_encoding;
-		
-		if ( ! in_array($this->charset, $this->_base_charsets, TRUE))
-			$this->_encoding = "8bit";
-			
-		if ($return == true)
-			return $this->_encoding;
-	}
-
-	// --------------------------------------------------------------------
-
-	/**
-	 * Get content type (text/html/attachment)
-	 *
-	 * @access	private
-	 * @return	string
-	 */	
-	function _get_content_type()
-	{	
-			if	($this->mailtype == 'html' &&  count($this->_attach_name) == 0)
-				return 'html';
-	
-		elseif	($this->mailtype == 'html' &&  count($this->_attach_name)  > 0)
-				return 'html-attach';				
-				
-		elseif	($this->mailtype == 'text' &&  count($this->_attach_name)  > 0)
-				return 'plain-attach';
-				
-		  else	return 'plain';
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Set RFC 822 Date
-	 *
-	 * @access	public
-	 * @return	string
-	 */	
-	function _set_date()
-	{
-		$timezone = date("Z");
-		$operator = (substr($timezone, 0, 1) == '-') ? '-' : '+';
-		$timezone = abs($timezone);
-		$timezone = floor($timezone/3600) * 100 + ($timezone % 3600 ) / 60;
-		
-		return sprintf("%s %s%04d", date("D, j M Y H:i:s"), $operator, $timezone);
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Mime message
-	 *
-	 * @access	private
-	 * @return	string
-	 */	
-	function _get_mime_message()
-	{
-		return "This is a multi-part message in MIME format.".$this->newline."Your email application may not support this format.";
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Validate Email Address
-	 *
-	 * @access	public
-	 * @param	string
-	 * @return	bool
-	 */	
-	function validate_email($email)
-	{	
-		if ( ! is_array($email))
-		{
-			$this->_set_error_message('email_must_be_array');		
-			return FALSE;
-		}
-
-		foreach ($email as $val)
-		{
-			if ( ! $this->valid_email($val))
-			{
-				$this->_set_error_message('email_invalid_address', $val);				
-				return FALSE;
-			}
-		}
-	}	
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Email Validation
-	 *
-	 * @access	public
-	 * @param	string
-	 * @return	bool
-	 */	
-	function valid_email($address)
-	{
-		if ( ! preg_match("/^([a-z0-9\+_\-]+)(\.[a-z0-9\+_\-]+)*@([a-z0-9\-]+\.)+[a-z]{2,6}$/ix", $address))
-			return FALSE;
-		else
-			return TRUE;
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Clean Extended Email Address: Joe Smith <joe@smith.com>
-	 *
-	 * @access	public
-	 * @param	string
-	 * @return	string
-	 */	
-	function clean_email($email)
-	{
-		if ( ! is_array($email))
-		{
-			if (preg_match('/\<(.*)\>/', $email, $match))
-		   		return $match['1'];
-		   	else
-		   		return $email;
-		}
-			
-		$clean_email = array();
-
-		for ($i=0; $i < count($email); $i++)
-		{
-			if (preg_match( '/\<(.*)\>/', $email[$i], $match))
-		   		$clean_email[] = $match['1'];
-		   	else
-		   		$clean_email[] = $email[$i];
-		}
-		
-		return $clean_email;
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Build alternative plain text message
-	 *
-	 * This function provides the raw message for use
-	 * in plain-text headers of HTML-formatted emails.
-	 * If the user hasn't specified his own alternative message
-	 * it creates one by stripping the HTML
-	 *
-	 * @access	private
-	 * @return	string
-	 */	
-	function _get_alt_message()
-	{
-		if ($this->alt_message != "")
-		{
-			return $this->word_wrap($this->alt_message, '76');
-		}
-	
-		if (eregi( '\<body(.*)\</body\>', $this->_body, $match))
-		{
-			$body = $match['1'];
-			$body = substr($body, strpos($body, ">") + 1);
-		}
-		else
-		{
-			$body = $this->_body;
-		}
-		
-		$body = trim(strip_tags($body));
-		$body = preg_replace( '#<!--(.*)--\>#', "", $body);
-		$body = str_replace("\t", "", $body);
-		
-		for ($i = 20; $i >= 3; $i--)
-		{
-			$n = "";
-			
-			for ($x = 1; $x <= $i; $x ++)
-				 $n .= "\n";
-		
-			$body = str_replace($n, "\n\n", $body);	
-		}
-
-		return $this->word_wrap($body, '76');
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Word Wrap
-	 *
-	 * @access	public
-	 * @param	string
-	 * @param	integer
-	 * @return	string
-	 */	
-	function word_wrap($str, $charlim = '')
-	{
-		// Se the character limit
-		if ($charlim == '')
-		{
-			$charlim = ($this->wrapchars == "") ? "76" : $this->wrapchars;
-		}
-		
-		// Reduce multiple spaces
-		$str = preg_replace("| +|", " ", $str);
-		
-		// Standardize newlines
-		$str = preg_replace("/\r\n|\r/", "\n", $str);
-		
-		// If the current word is surrounded by {unwrap} tags we'll 
-		// strip the entire chunk and replace it with a marker.
-		$unwrap = array();
-		if (preg_match_all("|(\{unwrap\}.+?\{/unwrap\})|s", $str, $matches))
-		{
-			for ($i = 0; $i < count($matches['0']); $i++)
-			{
-				$unwrap[] = $matches['1'][$i];				
-				$str = str_replace($matches['1'][$i], "{{unwrapped".$i."}}", $str);
-			}
-		}
-		
-		// Use PHP's native function to do the initial wordwrap.  
-		// We set the cut flag to FALSE so that any individual words that are 
-		// too long get left alone.  In the next step we'll deal with them.
-		$str = wordwrap($str, $charlim, "\n", FALSE);
-		
-		// Split the string into individual lines of text and cycle through them
-		$output = "";
-		foreach (explode("\n", $str) as $line) 
-		{
-			// Is the line within the allowed character count?
-			// If so we'll join it to the output and continue
-			if (strlen($line) <= $charlim)
-			{
-				$output .= $line.$this->newline;			
-				continue;
-			}
-				
-			$temp = '';
-			while((strlen($line)) > $charlim) 
-			{
-				// If the over-length word is a URL we won't wrap it
-				if (preg_match("!\[url.+\]|://|wwww.!", $line))
-				{
-					break;
-				}
-
-				// Trim the word down
-				$temp .= substr($line, 0, $charlim-1);
-				$line = substr($line, $charlim-1);
-			}
-			
-			// If $temp contains data it means we had to split up an over-length 
-			// word into smaller chunks so we'll add it back to our current line
-			if ($temp != '')
-			{
-				$output .= $temp.$this->newline.$line;
-			}
-			else
-			{
-				$output .= $line;
-			}
-
-			$output .= $this->newline;
-		}
-
-		// Put our markers back
-		if (count($unwrap) > 0)
-		{	
-			foreach ($unwrap as $key => $val)
-			{
-				$output = str_replace("{{unwrapped".$key."}}", $val, $output);
-			}
-		}
-
-		return $output;	
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Build final headers
-	 *
-	 * @access	public
-	 * @param	string
-	 * @return	string
-	 */	
-	function _build_headers()
-	{
-		$this->_set_header('X-Sender', $this->clean_email($this->_headers['From']));
-		$this->_set_header('X-Mailer', $this->useragent);		
-		$this->_set_header('X-Priority', $this->_priorities[$this->priority - 1]);
-		$this->_set_header('Message-ID', $this->_get_message_id());		
-		$this->_set_header('Mime-Version', '1.0');
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Write Headers as a string
-	 *
-	 * @access	public
-	 * @return	void
-	 */		
-	function _write_headers()
-	{
-		if ($this->protocol == 'mail')
-		{		
-			$this->_subject = $this->_headers['Subject'];
-			unset($this->_headers['Subject']);
-		}	
-
-		reset($this->_headers);
-		$this->_header_str = "";
-				
-		foreach($this->_headers as $key => $val)
-		{
-			$val = trim($val);
-		
-			if ($val != "")
-			{
-				$this->_header_str .= $key.": ".$val.$this->newline;
-			}
-		}
-		
-		if ($this->_get_protocol() == 'mail')
-			$this->_header_str = substr($this->_header_str, 0, -1);				
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Build Final Body and attachments
-	 *
-	 * @access	public
-	 * @return	void
-	 */	
-	function _build_message()
-	{
-		if ($this->wordwrap === TRUE  AND  $this->mailtype != 'html')
-		{
-			$this->_body = $this->word_wrap($this->_body);
-		}
-	
-		$this->_set_boundaries();
-		$this->_write_headers();
-		
-		$hdr = ($this->_get_protocol() == 'mail') ? $this->newline : '';
-			
-		switch ($this->_get_content_type())
-		{
-			case 'plain' :
-							
-				$hdr .= "Content-Type: text/plain; charset=" . $this->charset . $this->newline;
-				$hdr .= "Content-Transfer-Encoding: " . $this->_get_encoding();
-				
-				if ($this->_get_protocol() == 'mail')
-				{
-					$this->_header_str .= $hdr;
-					$this->_finalbody = $this->_body;
-					
-					return;
-				}
-				
-				$hdr .= $this->newline . $this->newline . $this->_body;
-				
-				$this->_finalbody = $hdr;
-				return;
-			
-			break;
-			case 'html' :
-								
-				$hdr .= "Content-Type: multipart/alternative; boundary=\"" . $this->_alt_boundary . "\"" . $this->newline;
-				$hdr .= $this->_get_mime_message() . $this->newline . $this->newline;
-				$hdr .= "--" . $this->_alt_boundary . $this->newline;
-				
-				$hdr .= "Content-Type: text/plain; charset=" . $this->charset . $this->newline;
-				$hdr .= "Content-Transfer-Encoding: " . $this->_get_encoding() . $this->newline . $this->newline;
-				$hdr .= $this->_get_alt_message() . $this->newline . $this->newline . "--" . $this->_alt_boundary . $this->newline;
-			
-				$hdr .= "Content-Type: text/html; charset=" . $this->charset . $this->newline;
-				$hdr .= "Content-Transfer-Encoding: quoted-printable";
-				
-				$this->_body = $this->_prep_quoted_printable($this->_body);
-				
-				if ($this->_get_protocol() == 'mail')
-				{
-					$this->_header_str .= $hdr;
-					$this->_finalbody = $this->_body . $this->newline . $this->newline . "--" . $this->_alt_boundary . "--";
-					
-					return;
-				}
-				
-				$hdr .= $this->newline . $this->newline;
-				$hdr .= $this->_body . $this->newline . $this->newline . "--" . $this->_alt_boundary . "--";
-
-				$this->_finalbody = $hdr;
-				return;
-		
-			break;
-			case 'plain-attach' :
-	
-				$hdr .= "Content-Type: multipart/".$this->multipart."; boundary=\"" . $this->_atc_boundary."\"" . $this->newline;
-				$hdr .= $this->_get_mime_message() . $this->newline . $this->newline;
-				$hdr .= "--" . $this->_atc_boundary . $this->newline;
-	
-				$hdr .= "Content-Type: text/plain; charset=" . $this->charset . $this->newline;
-				$hdr .= "Content-Transfer-Encoding: " . $this->_get_encoding();
-				
-				if ($this->_get_protocol() == 'mail')
-				{
-					$this->_header_str .= $hdr;		
-					
-					$body  = $this->_body . $this->newline . $this->newline;
-				}
-				
-				$hdr .= $this->newline . $this->newline;
-				$hdr .= $this->_body . $this->newline . $this->newline;
-
-			break;
-			case 'html-attach' :
-			
-				$hdr .= "Content-Type: multipart/".$this->multipart."; boundary=\"" . $this->_atc_boundary."\"" . $this->newline;
-				$hdr .= $this->_get_mime_message() . $this->newline . $this->newline;
-				$hdr .= "--" . $this->_atc_boundary . $this->newline;
-	
-				$hdr .= "Content-Type: multipart/alternative; boundary=\"" . $this->_alt_boundary . "\"" . $this->newline .$this->newline;
-				$hdr .= "--" . $this->_alt_boundary . $this->newline;
-				
-				$hdr .= "Content-Type: text/plain; charset=" . $this->charset . $this->newline;
-				$hdr .= "Content-Transfer-Encoding: " . $this->_get_encoding() . $this->newline . $this->newline;
-				$hdr .= $this->_get_alt_message() . $this->newline . $this->newline . "--" . $this->_alt_boundary . $this->newline;
-	
-				$hdr .= "Content-Type: text/html; charset=" . $this->charset . $this->newline;
-				$hdr .= "Content-Transfer-Encoding: quoted-printable";
-				
-				$this->_body = $this->_prep_quoted_printable($this->_body);
-				
-				if ($this->_get_protocol() == 'mail')
-				{
-					$this->_header_str .= $hdr;	
-					
-					$body  = $this->_body . $this->newline . $this->newline;
-					$body .= "--" . $this->_alt_boundary . "--" . $this->newline . $this->newline;				
-				}
-				
-				$hdr .= $this->newline . $this->newline;
-				$hdr .= $this->_body . $this->newline . $this->newline;
-				$hdr .= "--" . $this->_alt_boundary . "--" . $this->newline . $this->newline;
-
-			break;
-		}
-
-		$attachment = array();
-
-		$z = 0;
-		
-		for ($i=0; $i < count($this->_attach_name); $i++)
-		{
-			$filename = $this->_attach_name[$i];
-			$basename = basename($filename);
-			$ctype = $this->_attach_type[$i];
-						
-			if ( ! file_exists($filename))
-			{
-				$this->_set_error_message('email_attachment_missing', $filename);
-				return FALSE;
-			}			
-
-			$h  = "--".$this->_atc_boundary.$this->newline;
-			$h .= "Content-type: ".$ctype."; ";
-			$h .= "name=\"".$basename."\"".$this->newline;
-			$h .= "Content-Disposition: ".$this->_attach_disp[$i].";".$this->newline;
-			$h .= "Content-Transfer-Encoding: base64".$this->newline;
-
-			$attachment[$z++] = $h;
-			$file = filesize($filename) +1;
-			
-			if ( ! $fp = fopen($filename, 'r'))
-			{
-				$this->_set_error_message('email_attachment_unredable', $filename);
-				return FALSE;
-			}
-			
-			$attachment[$z++] = chunk_split(base64_encode(fread($fp, $file)));				
-			fclose($fp);
-		}
-
-		if ($this->_get_protocol() == 'mail')
-		{
-			$this->_finalbody = $body . implode($this->newline, $attachment).$this->newline."--".$this->_atc_boundary."--";	
-			
-			return;
-		}
-		
-		$this->_finalbody = $hdr.implode($this->newline, $attachment).$this->newline."--".$this->_atc_boundary."--";	
-		
-		return;	
-	}
-  	
-	// --------------------------------------------------------------------
-	
-	/**
-	 * Prep Quoted Printable
-	 *
-	 * Prepares string for Quoted-Printable Content-Transfer-Encoding
-	 * Refer to RFC 2045 http://www.ietf.org/rfc/rfc2045.txt
-	 *
-	 * @access	public
-	 * @param	string
-	 * @param	integer
-	 * @return	string
-	 */
-	function _prep_quoted_printable($str, $charlim = '')
-	{
-		// Set the character limit
-		// Don't allow over 76, as that will make servers and MUAs barf
-		// all over quoted-printable data
-		if ($charlim == '' OR $charlim > '76')
-		{
-			$charlim = '76';
-		}
-
-		// Reduce multiple spaces
-		$str = preg_replace("| +|", " ", $str);
-
-		// Standardize newlines
-		$str = preg_replace("/\r\n|\r/", "\n", $str);
-
-		// We are intentionally wrapping so mail servers will encode characters
-		// properly and MUAs will behave, so {unwrap} must go!
-		$str = str_replace(array('{unwrap}', '{/unwrap}'), '', $str);
-		
-		// Break into an array of lines
-		$lines = preg_split("/\n/", $str);
-
-	    $escape = '=';
-	    $output = '';
-
-		foreach ($lines as $line)
-		{
-			$length = strlen($line);
-			$temp = '';
-
-			// Loop through each character in the line to add soft-wrap
-			// characters at the end of a line " =\r\n" and add the newly
-			// processed line(s) to the output (see comment on $crlf class property)
-			for ($i = 0; $i < $length; $i++)
-			{
-				// Grab the next character
-				$char = substr($line, $i, 1);
-				$ascii = ord($char);
-
-				// Convert spaces and tabs but only if it's the end of the line
-				if ($i == ($length - 1))
-				{
-					$char = ($ascii == '32' OR $ascii == '9') ? $escape.sprintf('%02s', dechex($char)) : $char;
-				}
-
-				// encode = signs
-				if ($ascii == '61')
-				{
-					$char = $escape.strtoupper(sprintf('%02s', dechex($ascii)));  // =3D
-				}
-
-				// If we're at the character limit, add the line to the output,
-				// reset our temp variable, and keep on chuggin'
-				if ((strlen($temp) + strlen($char)) >= $charlim)
-				{
-					$output .= $temp.$escape.$this->crlf;
-					$temp = '';
-				}
-
-				// Add the character to our temporary line
-				$temp .= $char;
-			}
-
-			// Add our completed line to the output
-			$output .= $temp.$this->crlf;
-		}
-
-		// get rid of extra CRLF tacked onto the end
-		$output = substr($output, 0, strlen($this->crlf) * -1);
-
-		return $output;
-	}
-
-	// --------------------------------------------------------------------
-	
-	/**
-	 * Send Email
-	 *
-	 * @access	public
-	 * @return	bool
-	 */	
-	function send()
-	{			
-		if ($this->_replyto_flag == FALSE)
-		{
-			$this->reply_to($this->_headers['From']);
-		}
-	
-		if (( ! isset($this->_recipients) AND ! isset($this->_headers['To']))  AND
-			( ! isset($this->_bcc_array) AND ! isset($this->_headers['Bcc'])) AND
-			( ! isset($this->_headers['Cc'])))
-		{
-			$this->_set_error_message('email_no_recipients');					
-			return FALSE;
-		}
-
-		$this->_build_headers();
-		
-		if ($this->bcc_batch_mode  AND  count($this->_bcc_array) > 0)
-		{		
-			if (count($this->_bcc_array) > $this->bcc_batch_size)
-				return $this->batch_bcc_send();
-		}
-		
-		$this->_build_message();
-						
-		if ( ! $this->_spool_email())
-			return FALSE;
-		else
-			return TRUE;
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Batch Bcc Send.  Sends groups of BCCs in batches
-	 *
-	 * @access	public
-	 * @return	bool
-	 */	
-	function batch_bcc_send()
-	{
-		$float = $this->bcc_batch_size -1;
-		
-		$flag = 0;
-		$set = "";
-		
-		$chunk = array();		
-		
-		for ($i = 0; $i < count($this->_bcc_array); $i++)
-		{
-			if (isset($this->_bcc_array[$i]))
-				$set .= ", ".$this->_bcc_array[$i];
-		
-			if ($i == $float)
-			{	
-				$chunk[] = substr($set, 1);
-				$float = $float + $this->bcc_batch_size;
-				$set = "";
-			}
-			
-			if ($i == count($this->_bcc_array)-1)
-					$chunk[] = substr($set, 1);	
-		}
-
-		for ($i = 0; $i < count($chunk); $i++)
-		{
-			unset($this->_headers['Bcc']);
-			unset($bcc);
-
-			$bcc = $this->_str_to_array($chunk[$i]);
-			$bcc = $this->clean_email($bcc);
-	
-			if ($this->protocol != 'smtp')
-				$this->_set_header('Bcc', implode(", ", $bcc));
-			else
-				$this->_bcc_array = $bcc;
-			
-			$this->_build_message();
-			$this->_spool_email();		
-		}
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Unwrap special elements
-	 *
-	 * @access	private
-	 * @return	void
-	 */	
-	function _unwrap_specials()
-	{
-		$this->_finalbody = preg_replace_callback("/\{unwrap\}(.*?)\{\/unwrap\}/si", array($this, '_remove_nl_callback'), $this->_finalbody);
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Strip line-breaks via callback
-	 *
-	 * @access	private
-	 * @return	string
-	 */	
-	function _remove_nl_callback($matches)
-	{
-		return preg_replace("/(\r\n)|(\r)|(\n)/", "", $matches['1']);
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Spool mail to the mail server
-	 *
-	 * @access	private
-	 * @return	bool
-	 */	
-	function _spool_email()
-	{
-		$this->_unwrap_specials();
-
-		switch ($this->_get_protocol())
-		{
-			case 'mail'	:
-			
-					if ( ! $this->_send_with_mail())
-					{
-						$this->_set_error_message('email_send_failure_phpmail');							
-						return FALSE;
-					}
-			break;
-			case 'sendmail'	:
-								
-					if ( ! $this->_send_with_sendmail())
-					{
-						$this->_set_error_message('email_send_failure_sendmail');							
-						return FALSE;
-					}
-			break;
-			case 'smtp'	:
-								
-					if ( ! $this->_send_with_smtp())
-					{
-						$this->_set_error_message('email_send_failure_smtp');							
-						return FALSE;
-					}
-			break;
-
-		}
-
-		$this->_set_error_message('email_sent', $this->_get_protocol());
-		return true;
-	}	
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Send using mail()
-	 *
-	 * @access	private
-	 * @return	bool
-	 */	
-	function _send_with_mail()
-	{	
-		if ($this->_safe_mode == TRUE)
-		{
-			if ( ! mail($this->_recipients, $this->_subject, $this->_finalbody, $this->_header_str))
-				return FALSE;
-			else
-				return TRUE;		
-		}
-		else
-		{
-			if ( ! mail($this->_recipients, $this->_subject, $this->_finalbody, $this->_header_str, "-f".$this->clean_email($this->_headers['From'])))
-				return FALSE;
-			else
-				return TRUE;
-		}
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Send using Sendmail
-	 *
-	 * @access	private
-	 * @return	bool
-	 */	
-	function _send_with_sendmail()
-	{
-		$fp = @popen($this->mailpath . " -oi -f ".$this->clean_email($this->_headers['From'])." -t", 'w');
-		
-		if ( ! is_resource($fp))
-		{								
-			$this->_set_error_message('email_no_socket');				
-			return FALSE;
-		}
-		
-		fputs($fp, $this->_header_str);		
-		fputs($fp, $this->_finalbody);
-		pclose($fp) >> 8 & 0xFF;
-		
-		return TRUE;
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Send using SMTP
-	 *
-	 * @access	private
-	 * @return	bool
-	 */	
-	function _send_with_smtp()
-	{	
-		if ($this->smtp_host == '')
-		{	
-			$this->_set_error_message('email_no_hostname');		
-			return FALSE;
-		}
-
-		$this->_smtp_connect();
-		$this->_smtp_authenticate();
-		
-		$this->_send_command('from', $this->clean_email($this->_headers['From']));
-
-		foreach($this->_recipients as $val)
-			$this->_send_command('to', $val);
-			
-		if (count($this->_cc_array) > 0)
-		{
-			foreach($this->_cc_array as $val)
-			{
-				if ($val != "")
-				$this->_send_command('to', $val);
-			}
-		}
-
-		if (count($this->_bcc_array) > 0)
-		{
-			foreach($this->_bcc_array as $val)
-			{
-				if ($val != "")
-				$this->_send_command('to', $val);
-			}
-		}
-		
-		$this->_send_command('data');
-
-		$this->_send_data($this->_header_str . $this->_finalbody);
-		
-		$this->_send_data('.');
-
-		$reply = $this->_get_smtp_data();
-		
-		$this->_set_error_message($reply);			
-
-		if (substr($reply, 0, 3) != '250')
-		{
-			$this->_set_error_message('email_smtp_error', $reply);			
-			return FALSE;
-		}
-
-		$this->_send_command('quit');
-		return true;
-	}	
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * SMTP Connect
-	 *
-	 * @access	public
-	 * @param	string
-	 * @return	string
-	 */	
-	function _smtp_connect()
-	{
-	
-		$this->_smtp_connect = fsockopen($this->smtp_host,
-										$this->smtp_port,
-										$errno,
-										$errstr,
-										$this->smtp_timeout);
-
-		if( ! is_resource($this->_smtp_connect))
-		{								
-			$this->_set_error_message('email_smtp_error', $errno." ".$errstr);				
-			return FALSE;
-		}
-
-		$this->_set_error_message($this->_get_smtp_data());
-		return $this->_send_command('hello');
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Send SMTP command
-	 *
-	 * @access	private
-	 * @param	string
-	 * @param	string
-	 * @return	string
-	 */	
-	function _send_command($cmd, $data = '')
-	{
-		switch ($cmd)
-		{
-			case 'hello' :
-		
-					if ($this->_smtp_auth OR $this->_get_encoding() == '8bit')
-						$this->_send_data('EHLO '.$this->_get_hostname());
-					else
-						$this->_send_data('HELO '.$this->_get_hostname());
-						
-						$resp = 250;
-			break;
-			case 'from' :
-			
-						$this->_send_data('MAIL FROM:<'.$data.'>');
-
-						$resp = 250;
-			break;
-			case 'to'	:
-			
-						$this->_send_data('RCPT TO:<'.$data.'>');
-
-						$resp = 250;			
-			break;
-			case 'data'	:
-			
-						$this->_send_data('DATA');
-
-						$resp = 354;			
-			break;
-			case 'quit'	:
-		
-						$this->_send_data('QUIT');
-						
-						$resp = 221;
-			break;
-		}
-		
-		$reply = $this->_get_smtp_data();	
-		
-		$this->_debug_msg[] = "<pre>".$cmd.": ".$reply."</pre>";
-
-		if (substr($reply, 0, 3) != $resp)
-		{
-			$this->_set_error_message('email_smtp_error', $reply);				
-			return FALSE;
-		}
-			
-		if ($cmd == 'quit')
-			fclose($this->_smtp_connect);
-	
-		return true;
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 *  SMTP Authenticate
-	 *
-	 * @access	private
-	 * @return	bool
-	 */	
-	function _smtp_authenticate()
-	{	
-		if ( ! $this->_smtp_auth)
-			return true;
-			
-		if ($this->smtp_user == ""  AND  $this->smtp_pass == "")
-		{
-			$this->_set_error_message('email_no_smtp_unpw');
-			return FALSE;
-		}
-
-		$this->_send_data('AUTH LOGIN');
-
-		$reply = $this->_get_smtp_data();			
-
-		if (substr($reply, 0, 3) != '334')
-		{
-			$this->_set_error_message('email_filed_smtp_login', $reply);			
-			return FALSE;
-		}
-
-		$this->_send_data(base64_encode($this->smtp_user));
-
-		$reply = $this->_get_smtp_data();			
-
-		if (substr($reply, 0, 3) != '334')
-		{
-			$this->_set_error_message('email_smtp_auth_un', $reply);			
-			return FALSE;
-		}
-
-		$this->_send_data(base64_encode($this->smtp_pass));
-
-		$reply = $this->_get_smtp_data();			
-
-		if (substr($reply, 0, 3) != '235')
-		{
-			$this->_set_error_message('email_smtp_auth_pw', $reply);			
-			return FALSE;
-		}
-	
-		return true;
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Send SMTP data
-	 *
-	 * @access	private
-	 * @return	bool
-	 */	
-	function _send_data($data)
-	{
-		if ( ! fwrite($this->_smtp_connect, $data . $this->newline))
-		{
-			$this->_set_error_message('email_smtp_data_failure', $data);			
-			return FALSE;
-		}
-		else
-			return true;
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Get SMTP data
-	 *
-	 * @access	private
-	 * @return	string
-	 */	
-	function _get_smtp_data()
-	{
-		$data = "";
-
-		while ($str = fgets($this->_smtp_connect, 512))
-		{
-			$data .= $str;
-			
-			if (substr($str, 3, 1) == " ")
-				break; 	
-		}
-		
-		return $data;
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Get Hostname
-	 *
-	 * @access	private
-	 * @return	string
-	 */		
-	function _get_hostname()
-	{	
-		return (isset($_SERVER['SERVER_NAME'])) ? $_SERVER['SERVER_NAME'] : 'localhost.localdomain';	
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Get IP
-	 *
-	 * @access	private
-	 * @return	string
-	 */		
-	function _get_ip()
-	{
-		if ($this->_IP !== FALSE)
-		{
-			return $this->_IP;
-		}
-	
-		$cip = (isset($_SERVER['HTTP_CLIENT_IP']) AND $_SERVER['HTTP_CLIENT_IP'] != "") ? $_SERVER['HTTP_CLIENT_IP'] : FALSE;
-		$rip = (isset($_SERVER['REMOTE_ADDR']) AND $_SERVER['REMOTE_ADDR'] != "") ? $_SERVER['REMOTE_ADDR'] : FALSE;
-		$fip = (isset($_SERVER['HTTP_X_FORWARDED_FOR']) AND $_SERVER['HTTP_X_FORWARDED_FOR'] != "") ? $_SERVER['HTTP_X_FORWARDED_FOR'] : FALSE;
-					
-		if ($cip && $rip) 	$this->_IP = $cip;	
-		elseif ($rip)		$this->_IP = $rip;
-		elseif ($cip)		$this->_IP = $cip;
-		elseif ($fip)		$this->_IP = $fip;
-		
-		if (strstr($this->_IP, ','))
-		{
-			$x = explode(',', $this->_IP);
-			$this->_IP = end($x);
-		}
-		
-		if ( ! preg_match( "/^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$/", $this->_IP))
-			$this->_IP = '0.0.0.0';
-		
-		unset($cip);
-		unset($rip);
-		unset($fip);
-		
-		return $this->_IP;
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Get Debug Message
-	 *
-	 * @access	public
-	 * @return	string
-	 */	
-	function print_debugger()
-	{		
-		$msg = '';
-		
-		if (count($this->_debug_msg) > 0)
-		{
-			foreach ($this->_debug_msg as $val)
-			{
-				$msg .= $val;
-			}
-		}
-		
-		$msg .= "<pre>".$this->_header_str."\n".htmlspecialchars($this->_subject)."\n".htmlspecialchars($this->_finalbody).'</pre>';	
-		return $msg;
-	}	
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Set Message
-	 *
-	 * @access	public
-	 * @param	string
-	 * @return	string
-	 */	
-	function _set_error_message($msg, $val = '')
-	{
-		$CI =& get_instance();
-		$CI->lang->load('email');
-	
-		if (FALSE === ($line = $CI->lang->line($msg)))
-		{	
-			$this->_debug_msg[] = str_replace('%s', $val, $msg)."<br />";
-		}	
-		else
-		{
-			$this->_debug_msg[] = str_replace('%s', $val, $line)."<br />";
-		}	
-	}
-  	
-	// --------------------------------------------------------------------
-
-	/**
-	 * Mime Types
-	 *
-	 * @access	private
-	 * @param	string
-	 * @return	string
-	 */		
-	function _mime_types($ext = "")
-	{
-		$mimes = array(	'hqx'	=>	'application/mac-binhex40',
-						'cpt'	=>	'application/mac-compactpro',
-						'doc'	=>	'application/msword',
-						'bin'	=>	'application/macbinary',
-						'dms'	=>	'application/octet-stream',
-						'lha'	=>	'application/octet-stream',
-						'lzh'	=>	'application/octet-stream',
-						'exe'	=>	'application/octet-stream',
-						'class'	=>	'application/octet-stream',
-						'psd'	=>	'application/octet-stream',
-						'so'	=>	'application/octet-stream',
-						'sea'	=>	'application/octet-stream',
-						'dll'	=>	'application/octet-stream',
-						'oda'	=>	'application/oda',
-						'pdf'	=>	'application/pdf',
-						'ai'	=>	'application/postscript',
-						'eps'	=>	'application/postscript',
-						'ps'	=>	'application/postscript',
-						'smi'	=>	'application/smil',
-						'smil'	=>	'application/smil',
-						'mif'	=>	'application/vnd.mif',
-						'xls'	=>	'application/vnd.ms-excel',
-						'ppt'	=>	'application/vnd.ms-powerpoint',
-						'wbxml'	=>	'application/vnd.wap.wbxml',
-						'wmlc'	=>	'application/vnd.wap.wmlc',
-						'dcr'	=>	'application/x-director',
-						'dir'	=>	'application/x-director',
-						'dxr'	=>	'application/x-director',
-						'dvi'	=>	'application/x-dvi',
-						'gtar'	=>	'application/x-gtar',
-						'php'	=>	'application/x-httpd-php',
-						'php4'	=>	'application/x-httpd-php',
-						'php3'	=>	'application/x-httpd-php',
-						'phtml'	=>	'application/x-httpd-php',
-						'phps'	=>	'application/x-httpd-php-source',
-						'js'	=>	'application/x-javascript',
-						'swf'	=>	'application/x-shockwave-flash',
-						'sit'	=>	'application/x-stuffit',
-						'tar'	=>	'application/x-tar',
-						'tgz'	=>	'application/x-tar',
-						'xhtml'	=>	'application/xhtml+xml',
-						'xht'	=>	'application/xhtml+xml',
-						'zip'	=>	'application/zip',
-						'mid'	=>	'audio/midi',
-						'midi'	=>	'audio/midi',
-						'mpga'	=>	'audio/mpeg',
-						'mp2'	=>	'audio/mpeg',
-						'mp3'	=>	'audio/mpeg',
-						'aif'	=>	'audio/x-aiff',
-						'aiff'	=>	'audio/x-aiff',
-						'aifc'	=>	'audio/x-aiff',
-						'ram'	=>	'audio/x-pn-realaudio',
-						'rm'	=>	'audio/x-pn-realaudio',
-						'rpm'	=>	'audio/x-pn-realaudio-plugin',
-						'ra'	=>	'audio/x-realaudio',
-						'rv'	=>	'video/vnd.rn-realvideo',
-						'wav'	=>	'audio/x-wav',
-						'bmp'	=>	'image/bmp',
-						'gif'	=>	'image/gif',
-						'jpeg'	=>	'image/jpeg',
-						'jpg'	=>	'image/jpeg',
-						'jpe'	=>	'image/jpeg',
-						'png'	=>	'image/png',
-						'tiff'	=>	'image/tiff',
-						'tif'	=>	'image/tiff',
-						'css'	=>	'text/css',
-						'html'	=>	'text/html',
-						'htm'	=>	'text/html',
-						'shtml'	=>	'text/html',
-						'txt'	=>	'text/plain',
-						'text'	=>	'text/plain',
-						'log'	=>	'text/plain',
-						'rtx'	=>	'text/richtext',
-						'rtf'	=>	'text/rtf',
-						'xml'	=>	'text/xml',
-						'xsl'	=>	'text/xml',
-						'mpeg'	=>	'video/mpeg',
-						'mpg'	=>	'video/mpeg',
-						'mpe'	=>	'video/mpeg',
-						'qt'	=>	'video/quicktime',
-						'mov'	=>	'video/quicktime',
-						'avi'	=>	'video/x-msvideo',
-						'movie'	=>	'video/x-sgi-movie',
-						'doc'	=>	'application/msword',
-						'word'	=>	'application/msword',
-						'xl'	=>	'application/excel',
-						'eml'	=>	'message/rfc822'
-					);
-
-		return ( ! isset($mimes[strtolower($ext)])) ? "application/x-unknown-content-type" : $mimes[strtolower($ext)];
-	}
-
-}
-// END CI_Email class
-?>
\ No newline at end of file
+<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');/** * CodeIgniter * * An open source application development framework for PHP 4.3.2 or newer * * @package		CodeIgniter * @author		Rick Ellis * @copyright	Copyright (c) 2006, EllisLab, Inc. * @license		http://www.codeigniter.com/user_guide/license.html * @link		http://www.codeigniter.com * @since		Version 1.0 * @filesource */// ------------------------------------------------------------------------/** * CodeIgniter Email Class * * Permits email to be sent using Mail, Sendmail, or SMTP. * * @package		CodeIgniter * @subpackage	Libraries * @category	Libraries * @author		Rick Ellis * @link		http://www.codeigniter.com/user_guide/libraries/email.html */class CI_Email {	var	$useragent		= "CodeIgniter";	var	$mailpath		= "/usr/sbin/sendmail";	// Sendmail path	var	$protocol		= "mail";	// mail/sendmail/smtp	var	$smtp_host		= "";		// SMTP Server.  Example: mail.earthlink.net	var	$smtp_user		= "";		// SMTP Username	var	$smtp_pass		= "";		// SMTP Password	var	$smtp_port		= "25";		// SMTP Port	var	$smtp_timeout	= 5;		// SMTP Timeout in seconds	var	$wordwrap		= TRUE;		// true/false  Turns word-wrap on/off	var	$wrapchars		= "76";		// Number of characters to wrap at.	var	$mailtype		= "text";	// text/html  Defines email formatting	var	$charset		= "utf-8";	// Default char set: iso-8859-1 or us-ascii	var	$multipart		= "mixed";	// "mixed" (in the body) or "related" (separate)	var $alt_message	= '';		// Alternative message for HTML emails	var	$validate		= FALSE;	// true/false.  Enables email validation	var	$priority		= "3";		// Default priority (1 - 5)	var	$newline		= "\n";		// Default newline. "\r\n" or "\n" (Use "\r\n" to comply with RFC 822)	var $crlf			= "\n";		// The RFC 2045 compliant CRLF for quoted-printable is "\r\n".  Apparently some servers,									// even on the receiving end think they need to muck with CRLFs, so using "\n", while									// distasteful, is the only thing that seems to work for all environments.	var	$bcc_batch_mode	= FALSE;	// true/false  Turns on/off Bcc batch feature	var	$bcc_batch_size	= 200;		// If bcc_batch_mode = true, sets max number of Bccs in each batch	var	$_subject		= "";	var	$_body			= "";	var	$_finalbody		= "";	var	$_alt_boundary	= "";	var	$_atc_boundary	= "";	var	$_header_str	= "";	var	$_smtp_connect	= "";	var	$_encoding		= "8bit";	var $_safe_mode		= FALSE;	var $_IP			= FALSE;	var	$_smtp_auth		= FALSE;	var $_replyto_flag	= FALSE;	var	$_debug_msg		= array();	var	$_recipients	= array();	var	$_cc_array		= array();	var	$_bcc_array		= array();	var	$_headers		= array();	var	$_attach_name	= array();	var	$_attach_type	= array();	var	$_attach_disp	= array();	var	$_protocols		= array('mail', 'sendmail', 'smtp');	var	$_base_charsets	= array('iso-8859-1', 'us-ascii');	var	$_bit_depths	= array('7bit', '8bit');	var	$_priorities	= array('1 (Highest)', '2 (High)', '3 (Normal)', '4 (Low)', '5 (Lowest)');		/**	 * Constructor - Sets Email Preferences	 *	 * The constructor can be passed an array of config values	 */		function CI_Email($config = array())	{				if (count($config) > 0)		{			$this->initialize($config);		}			log_message('debug', "Email Class Initialized");	}	// --------------------------------------------------------------------	/**	 * Initialize preferences	 *	 * @access	public	 * @param	array	 * @return	void	 */		function initialize($config = array())	{		$this->clear();		foreach ($config as $key => $val)		{			if (isset($this->$key))			{				$method = 'set_'.$key;								if (method_exists($this, $method))				{					$this->$method($val);				}				else				{					$this->$key = $val;				}						}		}		$this->_smtp_auth = ($this->smtp_user == '' AND $this->smtp_pass == '') ? FALSE : TRUE;					$this->_safe_mode = ((boolean)@ini_get("safe_mode") === FALSE) ? FALSE : TRUE;	}  		// --------------------------------------------------------------------	/**	 * Initialize the Email Data	 *	 * @access	public	 * @return	void	 */		function clear($clear_attachments = FALSE)	{		$this->_subject		= "";		$this->_body		= "";		$this->_finalbody	= "";		$this->_header_str	= "";		$this->_replyto_flag = FALSE;		$this->_recipients	= array();		$this->_headers		= array();		$this->_debug_msg	= array();				$this->_set_header('User-Agent', $this->useragent);						$this->_set_header('Date', $this->_set_date());				if ($clear_attachments !== FALSE)		{			$this->_attach_name = array();			$this->_attach_type = array();			$this->_attach_disp = array();		}   			}  		// --------------------------------------------------------------------	/**	 * Set FROM	 *	 * @access	public	 * @param	string	 * @param	string	 * @return	void	 */		function from($from, $name = '')	{		if (preg_match( '/\<(.*)\>/', $from, $match))			$from = $match['1'];		if ($this->validate)			$this->validate_email($this->_str_to_array($from));					if ($name != '' && substr($name, 0, 1) != '"')		{			$name = '"'.$name.'"';		}			$this->_set_header('From', $name.' <'.$from.'>');		$this->_set_header('Return-Path', '<'.$from.'>');	}  		// --------------------------------------------------------------------	/**	 * Set Reply-to	 *	 * @access	public	 * @param	string	 * @param	string	 * @return	void	 */		function reply_to($replyto, $name = '')	{		if (preg_match( '/\<(.*)\>/', $replyto, $match))			$replyto = $match['1'];		if ($this->validate)			$this->validate_email($this->_str_to_array($replyto));			if ($name == '')		{			$name = $replyto;		}		if (substr($name, 0, 1) != '"')		{			$name = '"'.$name.'"';		}		$this->_set_header('Reply-To', $name.' <'.$replyto.'>');		$this->_replyto_flag = TRUE;	}  		// --------------------------------------------------------------------	/**	 * Set Recipients	 *	 * @access	public	 * @param	string	 * @return	void	 */		function to($to)	{		$to = $this->_str_to_array($to);		$to = $this->clean_email($to);			if ($this->validate)			$this->validate_email($to);					if ($this->_get_protocol() != 'mail')			$this->_set_header('To', implode(", ", $to));		switch ($this->_get_protocol())		{			case 'smtp'		: $this->_recipients = $to;			break;			case 'sendmail'	: $this->_recipients = implode(", ", $to);			break;			case 'mail'		: $this->_recipients = implode(", ", $to);			break;		}		}  		// --------------------------------------------------------------------	/**	 * Set CC	 *	 * @access	public	 * @param	string	 * @return	void	 */		function cc($cc)	{			$cc = $this->_str_to_array($cc);		$cc = $this->clean_email($cc);		if ($this->validate)			$this->validate_email($cc);		$this->_set_header('Cc', implode(", ", $cc));				if ($this->_get_protocol() == "smtp")			$this->_cc_array = $cc;	}  		// --------------------------------------------------------------------	/**	 * Set BCC	 *	 * @access	public	 * @param	string	 * @param	string	 * @return	void	 */		function bcc($bcc, $limit = '')	{		if ($limit != '' && is_numeric($limit))		{			$this->bcc_batch_mode = true;			$this->bcc_batch_size = $limit;		}		$bcc = $this->_str_to_array($bcc);		$bcc = $this->clean_email($bcc);				if ($this->validate)			$this->validate_email($bcc);		if (($this->_get_protocol() == "smtp") OR ($this->bcc_batch_mode && count($bcc) > $this->bcc_batch_size))			$this->_bcc_array = $bcc;		else			$this->_set_header('Bcc', implode(", ", $bcc));	}  		// --------------------------------------------------------------------	/**	 * Set Email Subject	 *	 * @access	public	 * @param	string	 * @return	void	 */		function subject($subject)	{		$subject = preg_replace("/(\r\n)|(\r)|(\n)/", "", $subject);		$subject = preg_replace("/(\t)/", " ", $subject);				$this->_set_header('Subject', trim($subject));			}  		// --------------------------------------------------------------------	/**	 * Set Body	 *	 * @access	public	 * @param	string	 * @return	void	 */		function message($body)	{		$this->_body = stripslashes(rtrim(str_replace("\r", "", $body)));		}	 		// --------------------------------------------------------------------	/**	 * Assign file attachments	 *	 * @access	public	 * @param	string	 * @return	string	 */			function attach($filename, $disposition = 'attachment')	{					$this->_attach_name[] = $filename;		$this->_attach_type[] = $this->_mime_types(next(explode('.', basename($filename))));		$this->_attach_disp[] = $disposition; // Can also be 'inline'  Not sure if it matters	}	// --------------------------------------------------------------------	/**	 * Add a Header Item	 *	 * @access	public	 * @param	string	 * @param	string	 * @return	void	 */		function _set_header($header, $value)	{		$this->_headers[$header] = $value;	}  		// --------------------------------------------------------------------	/**	 * Convert a String to an Array	 *	 * @access	public	 * @param	string	 * @return	array	 */		function _str_to_array($email)	{		if ( ! is_array($email))		{				if (ereg(',$', $email))				$email = substr($email, 0, -1);						if (ereg('^,', $email))				$email = substr($email, 1);									if (ereg(',', $email))			{									$x = explode(',', $email);				$email = array();								for ($i = 0; $i < count($x); $i ++)					$email[] = trim($x[$i]);			}			else			{								$email = trim($email);				settype($email, "array");			}		}		return $email;	}  		// --------------------------------------------------------------------	/**	 * Set Multipart Value	 *	 * @access	public	 * @param	string	 * @return	void	 */		function set_alt_message($str = '')	{		$this->alt_message = ($str == '') ? '' : $str;	}  		// --------------------------------------------------------------------	/**	 * Set Mailtype	 *	 * @access	public	 * @param	string	 * @return	void	 */		function set_mailtype($type = 'text')	{		$this->mailtype = ($type == 'html') ? 'html' : 'text';	}  		// --------------------------------------------------------------------	/**	 * Set Wordwrap	 *	 * @access	public	 * @param	string	 * @return	void	 */		function set_wordwrap($wordwrap = TRUE)	{		$this->wordwrap = ($wordwrap === FALSE) ? FALSE : TRUE;	}  		// --------------------------------------------------------------------	/**	 * Set Protocol	 *	 * @access	public	 * @param	string	 * @return	void	 */		function set_protocol($protocol = 'mail')	{		$this->protocol = ( ! in_array($protocol, $this->_protocols, TRUE)) ? 'mail' : strtolower($protocol);	}  		// --------------------------------------------------------------------	/**	 * Set Priority	 *	 * @access	public	 * @param	integer	 * @return	void	 */		function set_priority($n = 3)	{		if ( ! is_numeric($n))		{			$this->priority = 3;			return;		}			if ($n < 1 OR $n > 5)		{			$this->priority = 3;			return;		}			$this->priority = $n;	}  		// --------------------------------------------------------------------	/**	 * Set Newline Character	 *	 * @access	public	 * @param	string	 * @return	void	 */		function set_newline($newline = "\n")	{		if ($newline != "\n" AND $newline != "\r\n" AND $newline != "\r")		{			$this->newline	= "\n";				return;		}			$this->newline	= $newline;		}  		// --------------------------------------------------------------------	/**	 * Set Message Boundary	 *	 * @access	private	 * @return	void	 */		function _set_boundaries()	{		$this->_alt_boundary = "B_ALT_".uniqid(''); // multipart/alternative		$this->_atc_boundary = "B_ATC_".uniqid(''); // attachment boundary	}  		// --------------------------------------------------------------------	/**	 * Get the Message ID	 *	 * @access	private	 * @return	string	 */		function _get_message_id()	{		$from = $this->_headers['Return-Path'];		$from = str_replace(">", "", $from);		$from = str_replace("<", "", $from);			return  "<".uniqid('').strstr($from, '@').">";		}  		// --------------------------------------------------------------------	/**	 * Get Mail Protocol	 *	 * @access	private	 * @param	bool	 * @return	string	 */		function _get_protocol($return = true)	{		$this->protocol = strtolower($this->protocol);		$this->protocol = ( ! in_array($this->protocol, $this->_protocols, TRUE)) ? 'mail' : $this->protocol;				if ($return == true)			return $this->protocol;	}  		// --------------------------------------------------------------------	/**	 * Get Mail Encoding	 *	 * @access	private	 * @param	bool	 * @return	string	 */		function _get_encoding($return = true)	{				$this->_encoding = ( ! in_array($this->_encoding, $this->_bit_depths)) ? '7bit' : $this->_encoding;				if ( ! in_array($this->charset, $this->_base_charsets, TRUE))			$this->_encoding = "8bit";					if ($return == true)			return $this->_encoding;	}	// --------------------------------------------------------------------	/**	 * Get content type (text/html/attachment)	 *	 * @access	private	 * @return	string	 */		function _get_content_type()	{				if	($this->mailtype == 'html' &&  count($this->_attach_name) == 0)				return 'html';			elseif	($this->mailtype == 'html' &&  count($this->_attach_name)  > 0)				return 'html-attach';										elseif	($this->mailtype == 'text' &&  count($this->_attach_name)  > 0)				return 'plain-attach';						  else	return 'plain';	}  		// --------------------------------------------------------------------	/**	 * Set RFC 822 Date	 *	 * @access	public	 * @return	string	 */		function _set_date()	{		$timezone = date("Z");		$operator = (substr($timezone, 0, 1) == '-') ? '-' : '+';		$timezone = abs($timezone);		$timezone = floor($timezone/3600) * 100 + ($timezone % 3600 ) / 60;				return sprintf("%s %s%04d", date("D, j M Y H:i:s"), $operator, $timezone);	}  		// --------------------------------------------------------------------	/**	 * Mime message	 *	 * @access	private	 * @return	string	 */		function _get_mime_message()	{		return "This is a multi-part message in MIME format.".$this->newline."Your email application may not support this format.";	}  		// --------------------------------------------------------------------	/**	 * Validate Email Address	 *	 * @access	public	 * @param	string	 * @return	bool	 */		function validate_email($email)	{			if ( ! is_array($email))		{			$this->_set_error_message('email_must_be_array');					return FALSE;		}		foreach ($email as $val)		{			if ( ! $this->valid_email($val))			{				$this->_set_error_message('email_invalid_address', $val);								return FALSE;			}		}	}	  		// --------------------------------------------------------------------	/**	 * Email Validation	 *	 * @access	public	 * @param	string	 * @return	bool	 */		function valid_email($address)	{		if ( ! preg_match("/^([a-z0-9\+_\-]+)(\.[a-z0-9\+_\-]+)*@([a-z0-9\-]+\.)+[a-z]{2,6}$/ix", $address))			return FALSE;		else			return TRUE;	}  		// --------------------------------------------------------------------	/**	 * Clean Extended Email Address: Joe Smith <joe@smith.com>	 *	 * @access	public	 * @param	string	 * @return	string	 */		function clean_email($email)	{		if ( ! is_array($email))		{			if (preg_match('/\<(.*)\>/', $email, $match))		   		return $match['1'];		   	else		   		return $email;		}					$clean_email = array();		for ($i=0; $i < count($email); $i++)		{			if (preg_match( '/\<(.*)\>/', $email[$i], $match))		   		$clean_email[] = $match['1'];		   	else		   		$clean_email[] = $email[$i];		}				return $clean_email;	}  		// --------------------------------------------------------------------	/**	 * Build alternative plain text message	 *	 * This function provides the raw message for use	 * in plain-text headers of HTML-formatted emails.	 * If the user hasn't specified his own alternative message	 * it creates one by stripping the HTML	 *	 * @access	private	 * @return	string	 */		function _get_alt_message()	{		if ($this->alt_message != "")		{			return $this->word_wrap($this->alt_message, '76');		}			if (eregi( '\<body(.*)\</body\>', $this->_body, $match))		{			$body = $match['1'];			$body = substr($body, strpos($body, ">") + 1);		}		else		{			$body = $this->_body;		}				$body = trim(strip_tags($body));		$body = preg_replace( '#<!--(.*)--\>#', "", $body);		$body = str_replace("\t", "", $body);				for ($i = 20; $i >= 3; $i--)		{			$n = "";						for ($x = 1; $x <= $i; $x ++)				 $n .= "\n";					$body = str_replace($n, "\n\n", $body);			}		return $this->word_wrap($body, '76');	}  		// --------------------------------------------------------------------	/**	 * Word Wrap	 *	 * @access	public	 * @param	string	 * @param	integer	 * @return	string	 */		function word_wrap($str, $charlim = '')	{		// Se the character limit		if ($charlim == '')		{			$charlim = ($this->wrapchars == "") ? "76" : $this->wrapchars;		}				// Reduce multiple spaces		$str = preg_replace("| +|", " ", $str);				// Standardize newlines		$str = preg_replace("/\r\n|\r/", "\n", $str);				// If the current word is surrounded by {unwrap} tags we'll 		// strip the entire chunk and replace it with a marker.		$unwrap = array();		if (preg_match_all("|(\{unwrap\}.+?\{/unwrap\})|s", $str, $matches))		{			for ($i = 0; $i < count($matches['0']); $i++)			{				$unwrap[] = $matches['1'][$i];								$str = str_replace($matches['1'][$i], "{{unwrapped".$i."}}", $str);			}		}				// Use PHP's native function to do the initial wordwrap.  		// We set the cut flag to FALSE so that any individual words that are 		// too long get left alone.  In the next step we'll deal with them.		$str = wordwrap($str, $charlim, "\n", FALSE);				// Split the string into individual lines of text and cycle through them		$output = "";		foreach (explode("\n", $str) as $line) 		{			// Is the line within the allowed character count?			// If so we'll join it to the output and continue			if (strlen($line) <= $charlim)			{				$output .= $line.$this->newline;							continue;			}							$temp = '';			while((strlen($line)) > $charlim) 			{				// If the over-length word is a URL we won't wrap it				if (preg_match("!\[url.+\]|://|wwww.!", $line))				{					break;				}				// Trim the word down				$temp .= substr($line, 0, $charlim-1);				$line = substr($line, $charlim-1);			}						// If $temp contains data it means we had to split up an over-length 			// word into smaller chunks so we'll add it back to our current line			if ($temp != '')			{				$output .= $temp.$this->newline.$line;			}			else			{				$output .= $line;			}			$output .= $this->newline;		}		// Put our markers back		if (count($unwrap) > 0)		{				foreach ($unwrap as $key => $val)			{				$output = str_replace("{{unwrapped".$key."}}", $val, $output);			}		}		return $output;		}  		// --------------------------------------------------------------------	/**	 * Build final headers	 *	 * @access	public	 * @param	string	 * @return	string	 */		function _build_headers()	{		$this->_set_header('X-Sender', $this->clean_email($this->_headers['From']));		$this->_set_header('X-Mailer', $this->useragent);				$this->_set_header('X-Priority', $this->_priorities[$this->priority - 1]);		$this->_set_header('Message-ID', $this->_get_message_id());				$this->_set_header('Mime-Version', '1.0');	}  		// --------------------------------------------------------------------	/**	 * Write Headers as a string	 *	 * @access	public	 * @return	void	 */			function _write_headers()	{		if ($this->protocol == 'mail')		{					$this->_subject = $this->_headers['Subject'];			unset($this->_headers['Subject']);		}			reset($this->_headers);		$this->_header_str = "";						foreach($this->_headers as $key => $val)		{			$val = trim($val);					if ($val != "")			{				$this->_header_str .= $key.": ".$val.$this->newline;			}		}				if ($this->_get_protocol() == 'mail')			$this->_header_str = substr($this->_header_str, 0, -1);					}  		// --------------------------------------------------------------------	/**	 * Build Final Body and attachments	 *	 * @access	public	 * @return	void	 */		function _build_message()	{		if ($this->wordwrap === TRUE  AND  $this->mailtype != 'html')		{			$this->_body = $this->word_wrap($this->_body);		}			$this->_set_boundaries();		$this->_write_headers();				$hdr = ($this->_get_protocol() == 'mail') ? $this->newline : '';					switch ($this->_get_content_type())		{			case 'plain' :											$hdr .= "Content-Type: text/plain; charset=" . $this->charset . $this->newline;				$hdr .= "Content-Transfer-Encoding: " . $this->_get_encoding();								if ($this->_get_protocol() == 'mail')				{					$this->_header_str .= $hdr;					$this->_finalbody = $this->_body;										return;				}								$hdr .= $this->newline . $this->newline . $this->_body;								$this->_finalbody = $hdr;				return;						break;			case 'html' :												$hdr .= "Content-Type: multipart/alternative; boundary=\"" . $this->_alt_boundary . "\"" . $this->newline;				$hdr .= $this->_get_mime_message() . $this->newline . $this->newline;				$hdr .= "--" . $this->_alt_boundary . $this->newline;								$hdr .= "Content-Type: text/plain; charset=" . $this->charset . $this->newline;				$hdr .= "Content-Transfer-Encoding: " . $this->_get_encoding() . $this->newline . $this->newline;				$hdr .= $this->_get_alt_message() . $this->newline . $this->newline . "--" . $this->_alt_boundary . $this->newline;							$hdr .= "Content-Type: text/html; charset=" . $this->charset . $this->newline;				$hdr .= "Content-Transfer-Encoding: quoted-printable";								$this->_body = $this->_prep_quoted_printable($this->_body);								if ($this->_get_protocol() == 'mail')				{					$this->_header_str .= $hdr;					$this->_finalbody = $this->_body . $this->newline . $this->newline . "--" . $this->_alt_boundary . "--";										return;				}								$hdr .= $this->newline . $this->newline;				$hdr .= $this->_body . $this->newline . $this->newline . "--" . $this->_alt_boundary . "--";				$this->_finalbody = $hdr;				return;					break;			case 'plain-attach' :					$hdr .= "Content-Type: multipart/".$this->multipart."; boundary=\"" . $this->_atc_boundary."\"" . $this->newline;				$hdr .= $this->_get_mime_message() . $this->newline . $this->newline;				$hdr .= "--" . $this->_atc_boundary . $this->newline;					$hdr .= "Content-Type: text/plain; charset=" . $this->charset . $this->newline;				$hdr .= "Content-Transfer-Encoding: " . $this->_get_encoding();								if ($this->_get_protocol() == 'mail')				{					$this->_header_str .= $hdr;												$body  = $this->_body . $this->newline . $this->newline;				}								$hdr .= $this->newline . $this->newline;				$hdr .= $this->_body . $this->newline . $this->newline;			break;			case 'html-attach' :							$hdr .= "Content-Type: multipart/".$this->multipart."; boundary=\"" . $this->_atc_boundary."\"" . $this->newline;				$hdr .= $this->_get_mime_message() . $this->newline . $this->newline;				$hdr .= "--" . $this->_atc_boundary . $this->newline;					$hdr .= "Content-Type: multipart/alternative; boundary=\"" . $this->_alt_boundary . "\"" . $this->newline .$this->newline;				$hdr .= "--" . $this->_alt_boundary . $this->newline;								$hdr .= "Content-Type: text/plain; charset=" . $this->charset . $this->newline;				$hdr .= "Content-Transfer-Encoding: " . $this->_get_encoding() . $this->newline . $this->newline;				$hdr .= $this->_get_alt_message() . $this->newline . $this->newline . "--" . $this->_alt_boundary . $this->newline;					$hdr .= "Content-Type: text/html; charset=" . $this->charset . $this->newline;				$hdr .= "Content-Transfer-Encoding: quoted-printable";								$this->_body = $this->_prep_quoted_printable($this->_body);								if ($this->_get_protocol() == 'mail')				{					$this->_header_str .= $hdr;											$body  = $this->_body . $this->newline . $this->newline;					$body .= "--" . $this->_alt_boundary . "--" . $this->newline . $this->newline;								}								$hdr .= $this->newline . $this->newline;				$hdr .= $this->_body . $this->newline . $this->newline;				$hdr .= "--" . $this->_alt_boundary . "--" . $this->newline . $this->newline;			break;		}		$attachment = array();		$z = 0;				for ($i=0; $i < count($this->_attach_name); $i++)		{			$filename = $this->_attach_name[$i];			$basename = basename($filename);			$ctype = $this->_attach_type[$i];									if ( ! file_exists($filename))			{				$this->_set_error_message('email_attachment_missing', $filename);				return FALSE;			}						$h  = "--".$this->_atc_boundary.$this->newline;			$h .= "Content-type: ".$ctype."; ";			$h .= "name=\"".$basename."\"".$this->newline;			$h .= "Content-Disposition: ".$this->_attach_disp[$i].";".$this->newline;			$h .= "Content-Transfer-Encoding: base64".$this->newline;			$attachment[$z++] = $h;			$file = filesize($filename) +1;						if ( ! $fp = fopen($filename, 'r'))			{				$this->_set_error_message('email_attachment_unredable', $filename);				return FALSE;			}						$attachment[$z++] = chunk_split(base64_encode(fread($fp, $file)));							fclose($fp);		}		if ($this->_get_protocol() == 'mail')		{			$this->_finalbody = $body . implode($this->newline, $attachment).$this->newline."--".$this->_atc_boundary."--";							return;		}				$this->_finalbody = $hdr.implode($this->newline, $attachment).$this->newline."--".$this->_atc_boundary."--";					return;		}  		// --------------------------------------------------------------------		/**	 * Prep Quoted Printable	 *	 * Prepares string for Quoted-Printable Content-Transfer-Encoding	 * Refer to RFC 2045 http://www.ietf.org/rfc/rfc2045.txt	 *	 * @access	public	 * @param	string	 * @param	integer	 * @return	string	 */	function _prep_quoted_printable($str, $charlim = '')	{		// Set the character limit		// Don't allow over 76, as that will make servers and MUAs barf		// all over quoted-printable data		if ($charlim == '' OR $charlim > '76')		{			$charlim = '76';		}		// Reduce multiple spaces		$str = preg_replace("| +|", " ", $str);		// Standardize newlines		$str = preg_replace("/\r\n|\r/", "\n", $str);		// We are intentionally wrapping so mail servers will encode characters		// properly and MUAs will behave, so {unwrap} must go!		$str = str_replace(array('{unwrap}', '{/unwrap}'), '', $str);				// Break into an array of lines		$lines = preg_split("/\n/", $str);	    $escape = '=';	    $output = '';		foreach ($lines as $line)		{			$length = strlen($line);			$temp = '';			// Loop through each character in the line to add soft-wrap			// characters at the end of a line " =\r\n" and add the newly			// processed line(s) to the output (see comment on $crlf class property)			for ($i = 0; $i < $length; $i++)			{				// Grab the next character				$char = substr($line, $i, 1);				$ascii = ord($char);				// Convert spaces and tabs but only if it's the end of the line				if ($i == ($length - 1))				{					$char = ($ascii == '32' OR $ascii == '9') ? $escape.sprintf('%02s', dechex($char)) : $char;				}				// encode = signs				if ($ascii == '61')				{					$char = $escape.strtoupper(sprintf('%02s', dechex($ascii)));  // =3D				}				// If we're at the character limit, add the line to the output,				// reset our temp variable, and keep on chuggin'				if ((strlen($temp) + strlen($char)) >= $charlim)				{					$output .= $temp.$escape.$this->crlf;					$temp = '';				}				// Add the character to our temporary line				$temp .= $char;			}			// Add our completed line to the output			$output .= $temp.$this->crlf;		}		// get rid of extra CRLF tacked onto the end		$output = substr($output, 0, strlen($this->crlf) * -1);		return $output;	}	// --------------------------------------------------------------------		/**	 * Send Email	 *	 * @access	public	 * @return	bool	 */		function send()	{					if ($this->_replyto_flag == FALSE)		{			$this->reply_to($this->_headers['From']);		}			if (( ! isset($this->_recipients) AND ! isset($this->_headers['To']))  AND			( ! isset($this->_bcc_array) AND ! isset($this->_headers['Bcc'])) AND			( ! isset($this->_headers['Cc'])))		{			$this->_set_error_message('email_no_recipients');								return FALSE;		}		$this->_build_headers();				if ($this->bcc_batch_mode  AND  count($this->_bcc_array) > 0)		{					if (count($this->_bcc_array) > $this->bcc_batch_size)				return $this->batch_bcc_send();		}				$this->_build_message();								if ( ! $this->_spool_email())			return FALSE;		else			return TRUE;	}  		// --------------------------------------------------------------------	/**	 * Batch Bcc Send.  Sends groups of BCCs in batches	 *	 * @access	public	 * @return	bool	 */		function batch_bcc_send()	{		$float = $this->bcc_batch_size -1;				$flag = 0;		$set = "";				$chunk = array();						for ($i = 0; $i < count($this->_bcc_array); $i++)		{			if (isset($this->_bcc_array[$i]))				$set .= ", ".$this->_bcc_array[$i];					if ($i == $float)			{					$chunk[] = substr($set, 1);				$float = $float + $this->bcc_batch_size;				$set = "";			}						if ($i == count($this->_bcc_array)-1)					$chunk[] = substr($set, 1);			}		for ($i = 0; $i < count($chunk); $i++)		{			unset($this->_headers['Bcc']);			unset($bcc);			$bcc = $this->_str_to_array($chunk[$i]);			$bcc = $this->clean_email($bcc);				if ($this->protocol != 'smtp')				$this->_set_header('Bcc', implode(", ", $bcc));			else				$this->_bcc_array = $bcc;						$this->_build_message();			$this->_spool_email();				}	}  		// --------------------------------------------------------------------	/**	 * Unwrap special elements	 *	 * @access	private	 * @return	void	 */		function _unwrap_specials()	{		$this->_finalbody = preg_replace_callback("/\{unwrap\}(.*?)\{\/unwrap\}/si", array($this, '_remove_nl_callback'), $this->_finalbody);	}  		// --------------------------------------------------------------------	/**	 * Strip line-breaks via callback	 *	 * @access	private	 * @return	string	 */		function _remove_nl_callback($matches)	{		return preg_replace("/(\r\n)|(\r)|(\n)/", "", $matches['1']);	}  		// --------------------------------------------------------------------	/**	 * Spool mail to the mail server	 *	 * @access	private	 * @return	bool	 */		function _spool_email()	{		$this->_unwrap_specials();		switch ($this->_get_protocol())		{			case 'mail'	:								if ( ! $this->_send_with_mail())					{						$this->_set_error_message('email_send_failure_phpmail');													return FALSE;					}			break;			case 'sendmail'	:													if ( ! $this->_send_with_sendmail())					{						$this->_set_error_message('email_send_failure_sendmail');													return FALSE;					}			break;			case 'smtp'	:													if ( ! $this->_send_with_smtp())					{						$this->_set_error_message('email_send_failure_smtp');													return FALSE;					}			break;		}		$this->_set_error_message('email_sent', $this->_get_protocol());		return true;	}	  		// --------------------------------------------------------------------	/**	 * Send using mail()	 *	 * @access	private	 * @return	bool	 */		function _send_with_mail()	{			if ($this->_safe_mode == TRUE)		{			if ( ! mail($this->_recipients, $this->_subject, $this->_finalbody, $this->_header_str))				return FALSE;			else				return TRUE;				}		else		{			if ( ! mail($this->_recipients, $this->_subject, $this->_finalbody, $this->_header_str, "-f".$this->clean_email($this->_headers['From'])))				return FALSE;			else				return TRUE;		}	}  		// --------------------------------------------------------------------	/**	 * Send using Sendmail	 *	 * @access	private	 * @return	bool	 */		function _send_with_sendmail()	{		$fp = @popen($this->mailpath . " -oi -f ".$this->clean_email($this->_headers['From'])." -t", 'w');				if ( ! is_resource($fp))		{											$this->_set_error_message('email_no_socket');							return FALSE;		}				fputs($fp, $this->_header_str);				fputs($fp, $this->_finalbody);		pclose($fp) >> 8 & 0xFF;				return TRUE;	}  		// --------------------------------------------------------------------	/**	 * Send using SMTP	 *	 * @access	private	 * @return	bool	 */		function _send_with_smtp()	{			if ($this->smtp_host == '')		{				$this->_set_error_message('email_no_hostname');					return FALSE;		}		$this->_smtp_connect();		$this->_smtp_authenticate();				$this->_send_command('from', $this->clean_email($this->_headers['From']));		foreach($this->_recipients as $val)			$this->_send_command('to', $val);					if (count($this->_cc_array) > 0)		{			foreach($this->_cc_array as $val)			{				if ($val != "")				$this->_send_command('to', $val);			}		}		if (count($this->_bcc_array) > 0)		{			foreach($this->_bcc_array as $val)			{				if ($val != "")				$this->_send_command('to', $val);			}		}				$this->_send_command('data');		$this->_send_data($this->_header_str . $this->_finalbody);				$this->_send_data('.');		$reply = $this->_get_smtp_data();				$this->_set_error_message($reply);					if (substr($reply, 0, 3) != '250')		{			$this->_set_error_message('email_smtp_error', $reply);						return FALSE;		}		$this->_send_command('quit');		return true;	}	  		// --------------------------------------------------------------------	/**	 * SMTP Connect	 *	 * @access	public	 * @param	string	 * @return	string	 */		function _smtp_connect()	{			$this->_smtp_connect = fsockopen($this->smtp_host,										$this->smtp_port,										$errno,										$errstr,										$this->smtp_timeout);		if( ! is_resource($this->_smtp_connect))		{											$this->_set_error_message('email_smtp_error', $errno." ".$errstr);							return FALSE;		}		$this->_set_error_message($this->_get_smtp_data());		return $this->_send_command('hello');	}  		// --------------------------------------------------------------------	/**	 * Send SMTP command	 *	 * @access	private	 * @param	string	 * @param	string	 * @return	string	 */		function _send_command($cmd, $data = '')	{		switch ($cmd)		{			case 'hello' :							if ($this->_smtp_auth OR $this->_get_encoding() == '8bit')						$this->_send_data('EHLO '.$this->_get_hostname());					else						$this->_send_data('HELO '.$this->_get_hostname());												$resp = 250;			break;			case 'from' :									$this->_send_data('MAIL FROM:<'.$data.'>');						$resp = 250;			break;			case 'to'	:									$this->_send_data('RCPT TO:<'.$data.'>');						$resp = 250;						break;			case 'data'	:									$this->_send_data('DATA');						$resp = 354;						break;			case 'quit'	:								$this->_send_data('QUIT');												$resp = 221;			break;		}				$reply = $this->_get_smtp_data();					$this->_debug_msg[] = "<pre>".$cmd.": ".$reply."</pre>";		if (substr($reply, 0, 3) != $resp)		{			$this->_set_error_message('email_smtp_error', $reply);							return FALSE;		}					if ($cmd == 'quit')			fclose($this->_smtp_connect);			return true;	}  		// --------------------------------------------------------------------	/**	 *  SMTP Authenticate	 *	 * @access	private	 * @return	bool	 */		function _smtp_authenticate()	{			if ( ! $this->_smtp_auth)			return true;					if ($this->smtp_user == ""  AND  $this->smtp_pass == "")		{			$this->_set_error_message('email_no_smtp_unpw');			return FALSE;		}		$this->_send_data('AUTH LOGIN');		$reply = $this->_get_smtp_data();					if (substr($reply, 0, 3) != '334')		{			$this->_set_error_message('email_filed_smtp_login', $reply);						return FALSE;		}		$this->_send_data(base64_encode($this->smtp_user));		$reply = $this->_get_smtp_data();					if (substr($reply, 0, 3) != '334')		{			$this->_set_error_message('email_smtp_auth_un', $reply);						return FALSE;		}		$this->_send_data(base64_encode($this->smtp_pass));		$reply = $this->_get_smtp_data();					if (substr($reply, 0, 3) != '235')		{			$this->_set_error_message('email_smtp_auth_pw', $reply);						return FALSE;		}			return true;	}  		// --------------------------------------------------------------------	/**	 * Send SMTP data	 *	 * @access	private	 * @return	bool	 */		function _send_data($data)	{		if ( ! fwrite($this->_smtp_connect, $data . $this->newline))		{			$this->_set_error_message('email_smtp_data_failure', $data);						return FALSE;		}		else			return true;	}  		// --------------------------------------------------------------------	/**	 * Get SMTP data	 *	 * @access	private	 * @return	string	 */		function _get_smtp_data()	{		$data = "";		while ($str = fgets($this->_smtp_connect, 512))		{			$data .= $str;						if (substr($str, 3, 1) == " ")				break; 			}				return $data;	}  		// --------------------------------------------------------------------	/**	 * Get Hostname	 *	 * @access	private	 * @return	string	 */			function _get_hostname()	{			return (isset($_SERVER['SERVER_NAME'])) ? $_SERVER['SERVER_NAME'] : 'localhost.localdomain';		}  		// --------------------------------------------------------------------	/**	 * Get IP	 *	 * @access	private	 * @return	string	 */			function _get_ip()	{		if ($this->_IP !== FALSE)		{			return $this->_IP;		}			$cip = (isset($_SERVER['HTTP_CLIENT_IP']) AND $_SERVER['HTTP_CLIENT_IP'] != "") ? $_SERVER['HTTP_CLIENT_IP'] : FALSE;		$rip = (isset($_SERVER['REMOTE_ADDR']) AND $_SERVER['REMOTE_ADDR'] != "") ? $_SERVER['REMOTE_ADDR'] : FALSE;		$fip = (isset($_SERVER['HTTP_X_FORWARDED_FOR']) AND $_SERVER['HTTP_X_FORWARDED_FOR'] != "") ? $_SERVER['HTTP_X_FORWARDED_FOR'] : FALSE;							if ($cip && $rip) 	$this->_IP = $cip;			elseif ($rip)		$this->_IP = $rip;		elseif ($cip)		$this->_IP = $cip;		elseif ($fip)		$this->_IP = $fip;				if (strstr($this->_IP, ','))		{			$x = explode(',', $this->_IP);			$this->_IP = end($x);		}				if ( ! preg_match( "/^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$/", $this->_IP))			$this->_IP = '0.0.0.0';				unset($cip);		unset($rip);		unset($fip);				return $this->_IP;	}  		// --------------------------------------------------------------------	/**	 * Get Debug Message	 *	 * @access	public	 * @return	string	 */		function print_debugger()	{				$msg = '';				if (count($this->_debug_msg) > 0)		{			foreach ($this->_debug_msg as $val)			{				$msg .= $val;			}		}				$msg .= "<pre>".$this->_header_str."\n".htmlspecialchars($this->_subject)."\n".htmlspecialchars($this->_finalbody).'</pre>';			return $msg;	}	  		// --------------------------------------------------------------------	/**	 * Set Message	 *	 * @access	public	 * @param	string	 * @return	string	 */		function _set_error_message($msg, $val = '')	{		$CI =& get_instance();		$CI->lang->load('email');			if (FALSE === ($line = $CI->lang->line($msg)))		{				$this->_debug_msg[] = str_replace('%s', $val, $msg)."<br />";		}			else		{			$this->_debug_msg[] = str_replace('%s', $val, $line)."<br />";		}		}  		// --------------------------------------------------------------------	/**	 * Mime Types	 *	 * @access	private	 * @param	string	 * @return	string	 */			function _mime_types($ext = "")	{		$mimes = array(	'hqx'	=>	'application/mac-binhex40',						'cpt'	=>	'application/mac-compactpro',						'doc'	=>	'application/msword',						'bin'	=>	'application/macbinary',						'dms'	=>	'application/octet-stream',						'lha'	=>	'application/octet-stream',						'lzh'	=>	'application/octet-stream',						'exe'	=>	'application/octet-stream',						'class'	=>	'application/octet-stream',						'psd'	=>	'application/octet-stream',						'so'	=>	'application/octet-stream',						'sea'	=>	'application/octet-stream',						'dll'	=>	'application/octet-stream',						'oda'	=>	'application/oda',						'pdf'	=>	'application/pdf',						'ai'	=>	'application/postscript',						'eps'	=>	'application/postscript',						'ps'	=>	'application/postscript',						'smi'	=>	'application/smil',						'smil'	=>	'application/smil',						'mif'	=>	'application/vnd.mif',						'xls'	=>	'application/vnd.ms-excel',						'ppt'	=>	'application/vnd.ms-powerpoint',						'wbxml'	=>	'application/vnd.wap.wbxml',						'wmlc'	=>	'application/vnd.wap.wmlc',						'dcr'	=>	'application/x-director',						'dir'	=>	'application/x-director',						'dxr'	=>	'application/x-director',						'dvi'	=>	'application/x-dvi',						'gtar'	=>	'application/x-gtar',						'php'	=>	'application/x-httpd-php',						'php4'	=>	'application/x-httpd-php',						'php3'	=>	'application/x-httpd-php',						'phtml'	=>	'application/x-httpd-php',						'phps'	=>	'application/x-httpd-php-source',						'js'	=>	'application/x-javascript',						'swf'	=>	'application/x-shockwave-flash',						'sit'	=>	'application/x-stuffit',						'tar'	=>	'application/x-tar',						'tgz'	=>	'application/x-tar',						'xhtml'	=>	'application/xhtml+xml',						'xht'	=>	'application/xhtml+xml',						'zip'	=>	'application/zip',						'mid'	=>	'audio/midi',						'midi'	=>	'audio/midi',						'mpga'	=>	'audio/mpeg',						'mp2'	=>	'audio/mpeg',						'mp3'	=>	'audio/mpeg',						'aif'	=>	'audio/x-aiff',						'aiff'	=>	'audio/x-aiff',						'aifc'	=>	'audio/x-aiff',						'ram'	=>	'audio/x-pn-realaudio',						'rm'	=>	'audio/x-pn-realaudio',						'rpm'	=>	'audio/x-pn-realaudio-plugin',						'ra'	=>	'audio/x-realaudio',						'rv'	=>	'video/vnd.rn-realvideo',						'wav'	=>	'audio/x-wav',						'bmp'	=>	'image/bmp',						'gif'	=>	'image/gif',						'jpeg'	=>	'image/jpeg',						'jpg'	=>	'image/jpeg',						'jpe'	=>	'image/jpeg',						'png'	=>	'image/png',						'tiff'	=>	'image/tiff',						'tif'	=>	'image/tiff',						'css'	=>	'text/css',						'html'	=>	'text/html',						'htm'	=>	'text/html',						'shtml'	=>	'text/html',						'txt'	=>	'text/plain',						'text'	=>	'text/plain',						'log'	=>	'text/plain',						'rtx'	=>	'text/richtext',						'rtf'	=>	'text/rtf',						'xml'	=>	'text/xml',						'xsl'	=>	'text/xml',						'mpeg'	=>	'video/mpeg',						'mpg'	=>	'video/mpeg',						'mpe'	=>	'video/mpeg',						'qt'	=>	'video/quicktime',						'mov'	=>	'video/quicktime',						'avi'	=>	'video/x-msvideo',						'movie'	=>	'video/x-sgi-movie',						'doc'	=>	'application/msword',						'word'	=>	'application/msword',						'xl'	=>	'application/excel',						'eml'	=>	'message/rfc822'					);		return ( ! isset($mimes[strtolower($ext)])) ? "application/x-unknown-content-type" : $mimes[strtolower($ext)];	}}// END CI_Email class?>
\ No newline at end of file
diff --git a/user_guide/changelog.html b/user_guide/changelog.html
index 206480a..673111b 100644
--- a/user_guide/changelog.html
+++ b/user_guide/changelog.html
@@ -1,485 +1 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
-<head>
-
-<title>CodeIgniter User Guide : Change Log</title>
-
-<style type='text/css' media='all'>@import url('userguide.css');</style>
-<link rel='stylesheet' type='text/css' media='all' href='userguide.css' />
-
-<script type="text/javascript" src="./nav/nav.js"></script>
-<script type="text/javascript" src="./nav/prototype.lite.js"></script>
-<script type="text/javascript" src="./nav/moo.fx.js"></script>
-<script type="text/javascript" src="./nav/user_guide_menu.js"></script>
-
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta http-equiv='expires' content='-1' />
-<meta http-equiv= 'pragma' content='no-cache' />
-<meta name='robots' content='all' />
-<meta name='author' content='Rick Ellis' />
-<meta name='description' content='CodeIgniter User Guide' />
-
-</head>
-<body>
-
-<!-- START NAVIGATION -->
-<div id="nav"><div id="nav_inner"><script type="text/javascript">create_menu('./');</script></div></div>
-<div id="nav2"><a name="top"></a><a href="javascript:void(0);" onclick="myHeight.toggle();"><img src="./images/nav_toggle.jpg" width="153" height="44" border="0" title="Toggle Table of Contents" alt="Toggle Table of Contents" /></a></div>
-<div id="masthead">
-<table cellpadding="0" cellspacing="0" border="0" style="width:100%">
-<tr>
-<td><h1>CodeIgniter User Guide Version 1.5.4</h1></td>
-<td id="breadcrumb_right"><a href="./toc.html">Table of Contents Page</a></td>
-</tr>
-</table>
-</div>
-<!-- END NAVIGATION -->
-
-
-<!-- START BREADCRUMB -->
-<table cellpadding="0" cellspacing="0" border="0" style="width:100%">
-<tr>
-<td id="breadcrumb">
-<a href="http://www.codeigniter.com/">CodeIgniter Home</a> &nbsp;&#8250;&nbsp;
-<a href="index.html">User Guide Home</a> &nbsp;&#8250;&nbsp;
-Change Log
-</td>
-<td id="searchbox"><form method="get" action="http://www.google.com/search"><input type="hidden" name="as_sitesearch" id="as_sitesearch" value="codeigniter.com/user_guide/" />Search User Guide&nbsp; <input type="text" class="input" style="width:200px;" name="q" id="q" size="31" maxlength="255" value="" />&nbsp;<input type="submit" class="submit" name="sa" value="Go" /></form></td>
-</tr>
-</table>
-<!-- END BREADCRUMB -->
-
-<br clear="all" />
-
-
-<!-- START CONTENT -->
-<div id="content">
-
-<h1>Change Log</h1>
-
-<h2>Version 1.5.5</h2>
-<p>Release Date: -- still in development </p>
-<ul>
-	<li>Added Flashdata variables, session_id regeneration and configurable session update   times to the <a href="./libraries/sessions.html">Session class.</a></li>
-	<li>Added the ability to <a href="./general/autoloader.html">auto-load</a> <a href="./general/models.html">Models</a></li>
-	<li>Added $this->DB->save_queries variable to DB driver, enabling queries to get saved or no. Previously they were always saved.</li>
-	<li>Added <dfn>$assign_to_controller</dfn> variable in the main <kbd>index.php</kbd> file.  Anything that this variable contains will be passed automatically to a controller constructor when initialized.</li>
-	<li>Reorganized the URI and Routes classes for better clarity.</li>
-    <li>Javascript Calendar plugin now uses the months and days from the calendar language file, instead of hard-coded values, internationalizing it.</li>
-    <li>Removed &quot;rand()&quot; as a listed option from orderby in the <a href="./database/active_record.html">Active Record</a>, as it was MySQL only. </li>
-    <li>Added titles to all user manual pages.</li>
-    <li>Added a check for NULL fields in the MySQL database backup utility.</li>
-    <li>Documented the timezones() function in the <a href="./helpers/date_helper.html">Date Helper</a>.</li>
-    <li>Documented unset_userdata in the <a href="./libraries/sessions.html">Session class</a>.</li>
-    <li>Changed the behaviour of custom callbacks so that they no longer trigger the &quot;required&quot; rule. </li>
-    <li>Added a few additional mime type variations for CSV.</li>
-    <li>Fixed a bug in the <a href="./libraries/email.html">Email</a> library where some timezones were calculated incorrectly. </li>
-    <li>Fixed a bug in <a href="./libraries/validation.html">Validation</a> where valid_ip() wasn't called properly.</li>
-    <li>Fixed a bug in the Session library where user agent matching would fail on user agents ending with a space. </li>
-    <li>Fixed a bug in database driver where num_rows property wasn't getting updated.</li>
-    <li>Fixed a bug in captcha calling an invalid PHP function.</li>
-    <li>Fixed a bug in _html_entity_decode_callback() when 'global_xss_filtering' is enabled.</li>
-	<li>Fixed a bug in the cookie helper "set_cookie" function.  It was not honoring the config settings.</li>
-    <li>Fixed an example of comma-separated emails in the email library documentation.</li>
-    <li>Fixed an example in the Calendar library for Showing Next/Previous Month Links.</li>
-    <li>Fixed a typo in the database language file. </li>
-    <li>Fixed a typo in the docblock comments that had CodeIgniter spelled CodeIgnitor. </li>
-    <li>Fixed a typo in the <a href="./helpers/string_helper.html">String Helper</a> (uniquid changed to uniqid) </li>
-    <li>Fixed a typo in the DocBlock comment for unset_userdata() in Session.</li>
-    <li>Moved part of the userguide menu javascript to an external file. </li>
-</ul>
-
-
-
-
-
-<h2>Version 1.5.4</h2>
-<p>Release Date: July 12, 2007 </p>
-<ul>
-    <li>Added <a href="./libraries/language.html">custom Language files</a> to the <a href="./general/autoloader.html">autoload</a> options. </li>
-	<li>Added stripslashes() to the _clean_input_data() function in the <a href="./libraries/input.html">Input class</a> when magic quotes is on so that data will always be un-slashed within the framework.</li>
-	<li>Added array to string into the <a href="general/profiling.html">profiler</a>.</li>
-	<li>Added some additional mime types in application/config/mimes.php.</li>
-	<li>Added filename_security() method to <a href="./libraries/input.html">Input library</a>.</li>
-	<li>Added some additional arguments to the <a href="./helpers/inflector_helper.html">Inflection helper</a> singular() to compensate for words ending in "s".  Also added a force parameter to pluralize().</li>
-	<li>Added $config['charset'] to the config file.  Default value is 'UTF-8', used in some string handling functions.</li>
-	<li>Fixed MSSQL insert_id().</li>
-	<li>Fixed a logic error in the DB trans_status() function.  It was incorrectly returning TRUE on failure and FALSE on success.</li>
-	<li>Fixed a bug that was allowing multiple load attempts on extended classes.</li>
-	<li>Fixed a bug in the bootstrap file that was incorrectly attempting to discern the full server path even when it was explicity set by the user.</li>
-	<li>Fixed a bug in the escape_str() function in the MySQL driver.</li>
-    <li>Fixed a typo in the <a href="./libraries/calendar.html">Calendar library </a> </li>
-    <li>Fixed a typo in rpcs.php library</li>
-    <li>Fixed a bug in the <a href="./libraries/zip.html">Zip library</a>, providing PC Zip file compatibility with Mac OS X</li>
-    <li>Fixed a bug in router that was ignoring the scaffolding route for optimization </li>
-	<li>Fixed an IP validation bug.</li>
-	<li>Fixed a bug in display of POST keys in the <a href="./general/profiling.html">Profiler</a> output</li>
-	<li>Fixed a bug in display of queries with characters that would be interpreted as HTML in the <a href="./general/profiling.html">Profiler</a> output</li>
-	<li>Fixed a bug in display of Email class print debugger with characters that would be interpreted as HTML in the debugging output</li>
-	<li>Fixed a bug in the Content-Transfer-Encoding of HTML emails with the quoted-printable MIME type</li>
-	<li>Fixed a bug where one could unset certain PHP superglobals by setting them via GET or POST data</li>
-	<li>Fixed an undefined function error in the insert_id() function of the PostgreSQL driver</li>
-	<li>Fixed various doc typos. </li>
-	<li>Documented two functions from the <a href="./helpers/string_helper.html">String helper </a> that were missing from the user guide:  trim_slashes() and reduce_double_slashes().</li>
-	<li>Docs now validate to XHTML 1 transitional</li>
-    <li>Updated the XSS Filtering to take into account the IE expression() ability and improved certain deletions to prevent possible exploits</li>
-    <li>Modified the Router so that when Query Strings are Enabled, the controller trigger and function trigger values are sanitized for filename include security.</li>
-    <li>Modified the is_image() method in the Upload library to take into account Windows IE 6/7 eccentricities when dealing with MIMEs</li>
-    <li>Modified XSS Cleaning routine to be more performance friendly and compatible with PHP 5.2's new PCRE backtrack and recursion limits.</li>
-	<li>Modified the <a href="./helpers/url_helper.html">URL Helper</a> to type cast the $title as a string in case a numeric value is supplied</li>
-	<li>Modified Form Helper form_dropdown() to type cast the keys and values of the options array as strings, allowing numeric values to be properly set as 'selected'</li>
-	<li>Deprecated the use if <kbd>is_numeric()</kbd> in various places since it allows periods.  Due to compatibility problems with <kbd>ctype_digit()</kbd>, making it unreliable in some installations, the following regular expression was used instead:  <kbd>preg_match("/[^0-9]/", $n)</kbd></li>
-    <li>Deprecated: APPVER has been deprecated and replaced with CI_VERSION for clarity. </li>
-</ul>
-<h2>Version 1.5.3</h2>
-<p>Release Date: April 15, 2007 </p>
-<ul>
-    <li>Added array to string into the profiler </li>
-    <li>Code Igniter references updated to CodeIgniter </li>
-    <li>pMachine references updated to EllisLab </li>
-    <li>Fixed a bug in the repeater function of <a href="./helpers/string_helper.html">string helper</a>. </li>
-    <li>Fixed a bug in ODBC driver </li>
-    <li>Fixed a bug in result_array() that was returning an empty array when no result is produced.</li>
-    <li>Fixed a bug in the redirect function of the <a href="./helpers/url_helper.html">url helper</a>. </li>
-    <li>Fixed an undefined variable in Loader </li>
-    <li>Fixed a version bug in the Postgre driver </li>
-    <li>Fixed a bug in the textarea function of the form helper for use with strings</li>
-    <li>Fixed doc typos. </li>
-</ul>
-<h2>Version 1.5.2</h2>
-<p>Release Date: February 13, 2007 </p>
-<ul>
-    <li>Added <a href="./installation/downloads.html#svn">subversion information</a> to the <a href="./installation/downloads.html">downloads</a> page. </li>
-	<li>Added support for captions in the <a href="./libraries/table.html">Table Library</a> </li>
-	<li>Fixed a bug in the <a href="./helpers/download_helper.html">download_helper</a> that was causing Internet Explorer to load rather then download </li>
-    <li>Fixed a bug in the Active Record Join function that was not taking table prefixes into consideration.</li>
-    <li>Removed unescaped variables in error messages of Input and Router classes</li>
-    <li>Fixed a bug in the Loader that was causing errors on Libraries loaded twice. A debug message is now silently made in the log.  </li>
-    <li>Fixed a bug in the <a href="./helpers/form_helper.html">form helper</a> that gave textarea a value attribute </li>
-    <li>Fixed a bug in the <a href="./libraries/image_lib.php">Image Library</a> that was ignoring resizing the same size image </li>
-    <li>Fixed some doc typos.</li>
-</ul>
-
-
-<h2>Version 1.5.1</h2>
-<p>Release Date: November 23, 2006</p>
-<ul>
-    <li>Added support for submitting arrays of libraries in the $this-&gt;load-&gt;library function.</li>
-    <li>Added support for naming custom library files in lower or uppercase.</li>
-    <li>Fixed a bug related to output buffering.</li>
-    <li>Fixed a bug in the active record class that was not resetting query data after a completed query.</li>
-    <li>Fixed a bug that was suppressing errors in controllers.</li>
-    <li>Fixed a problem that can cause a loop to occur when the config file is missing.</li>
-    <li>Fixed a bug that occurred when multiple models were loaded with the third parameter set to TRUE.</li>
-    <li>Fixed an oversight that was not unsetting globals properly in the input sanitize function.</li>
-    <li>Fixed some bugs in the Oracle DB driver.</li>
-    <li>Fixed an incorrectly named variable in the MySQLi result driver.</li>
-    <li>Fixed some doc typos.</li>
-</ul>
-<h2>Version 1.5.0.1</h2>
-<p>Release Date: October 31, 2006</p>
-<ul>
-<li>Fixed a problem in which duplicate attempts to load helpers and classes were not being stopped.</li>
-<li>Fixed a bug in the word_wrap() helper function.</li>
-<li>Fixed an invalid color Hex number in the Profiler class.</li>
-<li>Fixed a corrupted image in the user guide.</li>
-</ul>
-
-
-
-<h2>Version 1.5.0</h2>
-<p>Release Date: October 30, 2006</p>
-
-<ul>
-<li>Added <a href="./database/utilities.html">DB utility class</a>, permitting DB backups, CVS or XML files from DB results, and various other functions.</li>
-<li>Added <a href="./database/caching.html">Database Caching Class</a>.</li>
-<li>Added <a href="./database/transactions.html">transaction support</a> to the database classes.</li>
-<li>Added <a href="./general/profiling.html">Profiler Class</a> which generates a report of Benchmark execution times, queries, and POST data at the bottom of your pages.</li>
-<li>Added <a href="./libraries/user_agent.html">User Agent Library</a> which allows browsers, robots, and mobile devises to be identified.</li>
-<li>Added <a href="./libraries/table.html">HTML Table Class</a> , enabling tables to be generated from arrays or database results.</li>
-<li>Added <a href="./libraries/zip.html">Zip Encoding Library</a>.</li>
-<li>Added <a href="./libraries/ftp.html">FTP Library</a>.</li>
-<li>Added the ability to <a href="./general/creating_libraries.html">extend libraries</a> and <a href="./general/core_classes.html">extend core classes</a>, in addition to being able to replace them.</li>
-<li>Added support for storing <a href="./general/models.html">models within sub-folders</a>.</li>
-<li>Added <a href="./helpers/download_helper.html">Download Helper</a>.</li>
-<li>Added <a href="./database/queries.html">simple_query()</a> function to the database classes</li>
-<li>Added <a href="./helpers/date_helper.html">standard_date()</a> function to the Date Helper.</li>
-<li>Added <a href="./database/results.html">$query->free_result()</a> to database class.</li>
-<li>Added <a href="./database/fields.html">$query->list_fields()</a> function to database class</li>
-<li>Added <a href="./database/helpers.html">$this->db->platform()</a> function</li>
-<li>Added new <a href="./helpers/file_helper.html">File Helper</a>:  get_filenames()</li>
-<li>Added new helper:  <a href="./helpers/smiley_helper.html">Smiley Helper</a></li>
-<li>Added support for &lt;ul> and &lt;ol> lists in the  <a href="./helpers/html_helper.html">HTML Helper</a></li>
-<li>Added the ability to rewrite <a href="./general/alternative_php.html">short tags</a> on-the-fly, converting them to standard PHP statements, for those servers that do not support short tags.  This allows the cleaner syntax to be used regardless of whether it's supported by the server.</li>
-<li>Added the ability to <a href="./general/managing_apps.html">rename or relocate the "application" folder</a>.</dfn>
-<li>Added more thorough initialization in the upload class so that all class variables are reset.</li>
-<li>Added "is_numeric" to validation, which uses the native PHP is_numeric function.</li>
-<li>Improved the URI handler to make it more reliable when the $config['uri_protocol'] item is set to AUTO.</li>
-<li>Moved most of the functions in the Controller class into the Loader class, allowing fewer reserved function names for controllers when running under PHP 5.</li>
-<li>Updated the DB Result class to return an empty array when $query->result() doesn't produce a result.</li>
-<li>Updated the <dfn>input->cookie()</dfn> and <dfn>input->post()</dfn> functions in <a href="./libraries/input.html">Input Class</a> to permit arrays contained cookies that are arrays to be run through the XSS filter.</li>
-<li>Documented three functions from the <a href="./libraries/validation.html">Validation class</a> that were missing from the user guide:  set_select(), set_radio(), and set_checkbox().</li>
-<li>Fixed a bug in the Email class related to SMTP Helo data.</li>
-<li>Fixed a bug in the word wrapping helper and function in the email class.</li>
-<li>Fixed a bug in the validation class.</li>
-<li>Fixed a bug in the typography helper that was incorrectly wrapping block level elements in paragraph tags.</li>
-<li>Fixed a problem in the form_prep() function that was double encoding entities.</li>
-<li>Fixed a bug that affects some versions of PHP when output buffering is nested.</li>
-<li>Fixed a bug that caused CI to stop working when the PHP magic __get() or __set() functions were used within models or controllers.</li>
-<li>Fixed a pagination bug that was permitting negative values in the URL.</li>
-<li>Fixed an oversight in which the Loader class was not allowed to be exteneded.</li>
-<li>Changed <dfn>_get_config()</dfn> to <dfn>get_config()</dfn> since the function is not a private one.</li>
-<li><strong>Deprecated "init" folder</strong>.  Initialization happens automatically now.  <a href="./general/creating_libraries.html">Please see documentation</a>.</li>
-<li><strong>Deprecated</strong> $this->db->field_names()  USE  $this->db->list_fields()</li>
-<li><strong>Deprecated</strong> the <dfn>$config['log_errors']</dfn> item from the config.php file.  Instead, <dfn>$config['log_threshold']</dfn> can be set to "0" to turn it off.</li>
-</ul>
-
-
-
-
-<h2>Version 1.4.1</h2>
-<p>Release Date: September 21, 2006</p>
-
-<ul>
-<li>Added a new feature that passes URI segments directly to your function calls as parameters. See the <a href="controllers.html">Controllers</a> page for more info.</li>
-<li>Added support for a function named <dfn>_output()</dfn>, which when used in your controllers will received the final rendered output from the output class.  More info in the <a href="controllers.html">Controllers</a> page.</li>
-<li>Added several new functions in the <a href="./libraries/uri.html">URI Class</a> to let you retrieve and manipulate URI segments that have been re-routed using the <a href="routing.html">URI Routing</a> feature. Previously, the URI class did not permit you to access any re-routed URI segments, but now it does.</li>
-<li>Added <a href="./libraries/output.html">$this->output->set_header()</a> function, which allows you to set server headers.</li>
-<li>Updated plugins, helpers, and language classes to allow your <dfn>application</dfn> folder to contain its own plugins, helpers, and language folders.  Previously they were always treated as global for your entire installation.  If your application folder contains any of these resources they will be used <em>instead</em> the global ones.</li>
-<li>Added <a href="./helpers/inflector_helper.html">Inflector helper</a>.</li>
-<li>Added <dfn>element()</dfn> function in the <a href="./helpers/array_helper.html">array helper</a>.</li>
-<li>Added <dfn>RAND()</dfn> to active record <dfn>orderby()</dfn> function.</li>
-<li>Added <dfn>delete_cookie()</dfn> and <dfn>get_cookie()</dfn> to <a href="./helpers/cookie_helper.html">Cookie helper</a>, even though the input class has a cookie fetching function.</li>
-<li>Added Oracle database driver (still undergoing testing so it might have some bugs).</li>
-<li>Added the ability to combine pseudo-variables and php variables in the template parser class.</li>
-<li>Added output compression option to the config file.</li>
-<li>Removed the is_numeric test from the db->escape() function.</li>
-<li>Fixed a MySQLi bug that was causing error messages not to contain proper error data.</li>
-<li>Fixed a bug in the email class which was causing it to ignore explicitly set alternative headers.</li>
-<li>Fixed a bug that was causing a PHP error when the Exceptions class was called within the get_config() function since it was causing problems.</li>
-<li>Fixed an oversight in the cookie helper in which the config file cookie settings were not being honored.</li>
-<li>Fixed an oversight in the upload class. An item mentioned in the 1.4 changelog was missing.</li>
-<li>Added some code to allow email attachments to be reset when sending batches of email.</li>
-<li>Deprecated the <dfn>application/scripts</dfn> folder. It will continue to work for legacy users, but it is recommended that you create your own
-<a href="./general/libraries.html">libraries</a> or <a href="./general/models.html">models</a> instead.  It was originally added before CI had user libraries or models, but it's not needed anymore.</li>
-<li>Deprecated the <dfn>$autoload['core']</dfn> item from the <kbd>autoload.php</kbd> file.  Instead, please now use: <kbd>$autoload['libraries']</kbd></li>
-<li>Deprecated the following database functions: $this->db->smart_escape_str() and $this->db->fields().</li>
-</ul>
-
-
-
-<h2>Version 1.4.0</h2>
-<p>Release Date: September 17, 2006</p>
-
-<ul>
-<li>Added <a href="hooks.html">Hooks</a> feature, enabling you to tap into and modify the inner workings of the framework without hacking the core files.</li>
-<li>Added the ability to organize controller files <a href="controllers.html">into sub-folders</a>.  Kudos to Marco for <a href="http://www.codeigniter.com/forums/viewthread/627/">suggesting</a> this (and the next two) feature.</li>
-<li>Added regular expressions support for <a href="routing.html">routing rules</a>.</li>
-<li>Added the ability to <a href="controllers.html">remap function calls</a> within your controllers.</li>
-<li>Added the ability to <a href="core_classes.html">replace core system classes</a> with your own classes.</li>
-<li>Added support for % character in URL.</li>
-<li>Added the ability to supply full URLs using the <a href="./helpers/url_helper.html">anchor()</a> helper function.</li>
-<li>Added mode parameter to <a href="./helpers/file_helper.html">file_write()</a> helper.</li>
-<li>Added support for changing the port number in the <a href="./database/configuration.html">Postgre driver</a>.</li>
-<li>Moved the list of "allowed URI characters" out of the Router class and into the config file.</li>
-<li>Moved the MIME type array out of the Upload class and into its own file in the applications/config/ folder.</li>
-<li>Updated the Upload class to allow the upload field name to be set when calling <a href="./libraries/file_uploading.html">do_upload()</a>.</li>
-<li>Updated the <a href="./libraries/config.html">Config Library</a> to be able to load config files silently, and to be able to assign config files to their own index (to avoid collisions if you use multiple config files).</li>
-<li>Updated the URI Protocol code to allow more options so that URLs will work more reliably in different environments.</li>
-<li>Updated the <dfn>form_open()</dfn> helper to allow the GET method to be used.</li>
-<li>Updated the MySQLi <dfn>execute()</dfn> function with some code to help prevent lost connection errors.</li>
-<li>Updated the SQLite Driver to check for object support before attempting to return results as objects.  If unsupported it returns an array.</li>
-<li>Updated the Models loader function to allow multiple loads of the same model.</li>
-<li>Updated the MS SQL driver so that single quotes are escaped.</li>
-<li>Updated the Postgre and ODBC drivers for better compatibility.</li>
-<li>Removed a strtolower() call that was changing URL segments to lower case.</li>
-<li>Removed some references that were interfering with PHP 4.4.1 compatibility.</li>
-<li>Removed backticks from Postgre class since these are not needed.</li>
-<li>Renamed <dfn>display()</dfn> to <dfn>_display()</dfn> in the Output class to make it clear that it's a private function.</li>
-<li>Deprecated the hash() function due to a naming conflict with a native PHP function with the same name.  Please use <kbd>dohash()</kbd> instead.</li>
-<li>Fixed an bug that was preventing the input class from unsetting GET variables.</li>
-<li>Fixed a router bug that was making it too greedy when matching end segments.</li>
-<li>Fixed a bug that was preventing multiple discreet database calls.</li>
-<li>Fixed a bug in which loading a language file was producing a "file contains no data" message.</li>
-<li>Fixed a session bug caused by the XSS Filtering feature inadvertently changing the case of certain words.</li>
-<li>Fixed some missing prefixes when using the database prefix feature.</li>
-<li>Fixed a typo in the Calendar class (cal_november).</li>
-<li>Fixed a bug in the <dfn>form_checkbox()</dfn> helper.</li>
-<li>Fixed a bug that was allowing the second segment of the URI to be identical to the class name.</li>
-<li>Fixed an evaluation bug in the database initialization function.</li>
-<li>Fixed a minor bug in one of the error messages in the language class.</li>
-<li>Fixed a bug in the date helper <dfn>timespan</dfn> function.</li>
-<li>Fixed an undefined variable in the DB Driver class.</li>
-<li>Fixed a bug in which dollar signs used as binding replacement values in the DB class would be treated as RegEx back-references.</li>
-<li>Fixed a bug in the <dfn>set_hash()</dfn> function which was preventing MD5 from being used.</li>
-<li>Fixed a couple bugs in the Unit Testing class.</li>
-<li>Fixed an incorrectly named variable in the Validation class.</li>
-<li>Fixed an incorrectly named variable in the URI class.</li>
-<li>Fixed a bug in the config class that was preventing the base URL from being called properly.</li>
-<li>Fixed a bug in the validation class that was not permitting callbacks if the form field was empty.</li>
-<li>Fixed a problem that was preventing scaffolding from working properly with MySQLi.</li>
-<li>Fixed some MS SQL bugs.</li>
-<li>Fixed some doc typos.</li>
-</ul>
-
-
-
-<h2>Version 1.3.3</h2>
-<p>Release Date: June 1, 2006</p>
-
-<ul>
-
-<li>Models do <strong>not</strong> connect automatically to the database as of this version. <a href="./general/models.html">More info here</a>.</li>
-<li>Updated the Sessions class to utilize the active record class when running session related queries.  Previously the queries assumed MySQL syntax.</li>
-<li>Updated alternator() function to re-initialize when called with no arguments, allowing multiple calls.</li>
-<li>Fixed a bug in the active record "having" function.</li>
-<li>Fixed a problem in the validation class which was making checkboxes be ignored when required.</li>
-<li>Fixed a bug in the word_limiter() helper function.  It was cutting off the fist word.</li>
-<li>Fixed a bug in the xss_clean function due to a PHP bug that affects some versions of html_entity_decode.</li>
-<li>Fixed a validation bug that was preventing rules from being set twice in one controller.</li>
-<li>Fixed a calendar bug that was not letting it use dynamically loaded languages.</li>
-<li>Fixed a bug in the active record class when using WHERE clauses with LIKE</li>
-<li>Fixed a bug in the hash() security helper.</li>
-<li>Fixed some typos.</li>
-</ul>
-
-
-
-
-<h2>Version 1.3.2</h2>
-<p>Release Date: April 17, 2006</p>
-
-<ul>
-<li>Changed the behavior of the validation class such that if a "required" rule is NOT explicitly stated for a field then all other tests get ignored.</li>
-<li>Fixed a bug in the Controller class that was causing it to look in the local "init" folder instead of the main system one.</li>
-<li>Fixed a bug in the init_pagination file.  The $config item was not being set correctly.</li>
-<li>Fixed a bug in the auto typography helper that was causing inconsistent behavior.</li>
-<li>Fixed a couple bugs in the Model class.</li>
-<li>Fixed some documentation typos and errata.</li>
-</ul>
-
-
-
-<h2>Version 1.3.1</h2>
-<p>Release Date: April 11, 2006</p>
-
-<ul>
-<li>Added a <a href="./libraries/unit_testing.html">Unit Testing Library</a>.</li>
-<li>Added the ability to pass objects to the <strong>insert()</strong> and <strong>update()</strong>  database functions.
-This feature enables you to (among other things) use your  <a href="./general/models.html">Model class</a> variables to run queries with. See the Models page for details.</li>
-<li>Added the ability to pass objects to the <a href="./general/views.html">view loading function</a>: $this->load->view('my_view', <var>$object</var>);</li>
-<li>Added <kbd>getwhere</kbd> function to <a href="./database/active_record.html">Active Record class</a>.</li>
-<li>Added <kbd>count_all</kbd> function to <a href="./database/active_record.html">Active Record class</a>.</li>
-<li>Added language file for scaffolding and fixed a scaffolding bug that occurs when there are no rows in the specified table.</li>
-<li>Added <a href="./database/queries.html">$this->db->last_query()</a>, which allows you to view your last query that was run.</li>
-<li>Added a new mime type to the upload class for better compatibility.</li>
-<li>Changed how cache files are read to prevent PHP errors if the cache file contains an XML tag, which PHP wants to interpret as a short tag.</li>
-<li>Fixed a bug in a couple of the active record functions (where and orderby).</li>
-<li>Fixed a bug in the image library when realpath() returns false.</li>
-<li>Fixed a bug in the Models that was preventing libraries from being used within them.</li>
-<li>Fixed a bug in the "exact_length" function of the validation class.</li>
-<li>Fixed some typos in the user guide</li>
-</ul>
-
-
-<h2>Version 1.3</h2>
-<p>Release Date: April 3, 2006</p>
-
-<ul>
-<li>Added support for <a href="models.html">Models</a>.</li>
-<li>Redesigned the database libraries to support additional RDBMs (Postgre, MySQLi, etc.).</li>
-<li>Redesigned the <a href="./database/active_record.html">Active Record class</a> to enable more varied types of queries with simpler syntax, and advanced features like JOINs.</li>
-<li>Added a feature to the database class that lets you run <a href="./database/call_function.html">custom function calls</a>.</li>
-<li>Added support for <a href="controllers.html">private functions</a> in your controllers.  Any controller function name that starts with an underscore will not be served by a URI request.</li>
-<li>Added the ability to pass your own initialization parameters to your <a href="creating_libraries.html">custom core libraries</a> when using $this->load->library()</li>
-<li>Added support for running standard <a href="urls.html">query string URLs</a>.  These can be optionally enabled in your config file.</li>
-<li>Added the ability to  <a href="urls.html">specify a "suffix"</a>, which will be appended to your URLs.  For example, you could add .html to your URLs, making them appear static. This feature is enabled in your config file.</li>
-<li>Added a new error template for use with native PHP errors.</li>
-<li>Added "alternator" function in the <a href="./helpers/string_helper.html">string helpers</a>.</p>
-<li>Removed slashing from the input class. After much debate we decided to kill this feature.</li>
-<li>Change the commenting style in the scripts to the PEAR standard so that IDEs and tools like phpDocumenter can harvest the comments.</li>
-<li>Added better class and function name-spacing to avoid collisions with user developed classes. All CodeIgniter classes are now prefixed with <dfn>CI_</dfn> and
-all controller methods are prefixed with <dfn>_ci</dfn> to avoid controller collisions. A list of reserved function names can be <a href="controllers.html">found here</a>.</li>
-<li>Redesigned how the "CI" super object is referenced, depending on whether PHP 4 or 5 is being run, since PHP 5 allows a more graceful way to manage objects that utilizes a bit less resources.</li>
-<li>Deprecated: <var>$this->db->use_table()</var> has been deprecated. Please read the <a href="./database/active_record.html">Active Record</a> page for information.</li>
-<li>Deprecated: <var>$this->db->smart_escape_str()</var> has been deprecated. Please use this instead: <var>$this->db->escape()</var></li>
-<li>Fixed a bug in the exception handler which was preventing some PHP errors from showing up.</li>
-<li>Fixed a typo in the URI class.  $this->total_segment() should be plural: $this->total_segments()</li>
-<li>Fixed some typos in the default calendar template</li>
-<li>Fixed some typos in the user guide</li>
-</ul>
-
-
-
-
-
-
-
-
-<h2>Version 1.2</h2>
-<p>Release Date: March 21, 2006</p>
-
-<ul>
-<li>Redesigned some internal aspects of the framework to resolve scoping problems that surfaced during the beta tests. The problem was most notable when instantiating classes in your constructors, particularly if those classes in turn did work in their constructors.</li>
-<li>Added a global function named <a href="ancillary_classes.html">get_instance()</a> allowing the main CodeIgniter object to be accessible throughout your own classes.</li>
-<li>Added new <a href="./helpers/file_helper.html">File Helper</a>:  delete_files()</li>
-<li>Added new <a href="./helpers/url_helper.html">URL Helpers</a>:  base_url(), index_page()</li>
-<li>Added the ability to create your own <a href="creating_libraries.html">core libraries</a> and store them in your local application directory.</li>
-<li>Added an <kbd>overwrite</kbd> option to the <a href="./libraries/file_uploading.html">Upload class</a>, enabling files to be overwritten rather than having the file name appended.</li>
-<li>Added Javascript Calendar plugin.</li>
-<li>Added search feature to user guide.  Note: This is done using Google, which at the time of this writing has not crawled all the pages of the docs.</li>
-<li>Updated the parser class so that it allows tag pars within other tag pairs.</li>
-<li>Fixed a bug in the DB "where" function.</li>
-<li>Fixed a bug that was preventing custom config files to be auto-loaded.</li>
-<li>Fixed a bug in the mysql class bind feature that prevented question marks in the replacement data.</li>
-<li>Fixed some bugs in the xss_clean function</li>
-</ul>
-
-
-
-
-
-<h2>Version Beta 1.1</h2>
-<p>Release Date: March 10, 2006</p>
-
-<ul>
-<li>Added a <a href="./libraries/calendar.html">Calendaring class</a>.</li>
-<li>Added support for running <a href="managing_apps.html">multiple applications</a> that share a common CodeIgniter backend.</li>
-<li>Moved the "uri protocol" variable from the index.php file into the config.php file</li>
-<li>Fixed a problem that was preventing certain function calls from working within constructors.</li>
-<li>Fixed a problem that was preventing the $this->load->library function from working in constructors.</li>
-<li>Fixed a bug that occurred when the session class was loaded using the auto-load routine.</li>
-<li>Fixed a bug that can happen with PHP versions that do not support the E_STRICT constant</li>
-<li>Fixed a data type error in the form_radio function (form helper)</li>
-<li>Fixed a bug that was preventing the xss_clean function from being called from the validation class.</li>
-<li>Fixed the cookie related config names, which were incorrectly specified as $conf rather than $config</li>
-<li>Fixed a pagination problem in the scaffolding.</li>
-<li>Fixed a bug in the mysql class "where" function.</li>
-<li>Fixed a regex problem in some code that trimmed duplicate slashes.</li>
-<li>Fixed a bug in the br() function in the HTML helper</li>
-<li>Fixed a syntax mistake in the form_dropdown function in the Form Helper.</li>
-<li>Removed the "style" attributes form the form helpers.</li>
-<li>Updated the documentation. Added "next/previous" links to each page and fixed various typos.</li>
-</ul>
-
-<h2>Version Beta 1.0 </h2>
-<p>Release Date: February 28, 2006</p>
-<p>First publicly released version.</p>
-
-</div>
-<!-- END CONTENT -->
-
-
-<div id="footer">
-<p>
-Previous Topic:&nbsp;&nbsp;<a href="license.html">License Agreement</a>
-&nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
-<a href="#top">Top of Page</a>&nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
-<a href="index.html">User Guide Home</a>&nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
-Next Topic:&nbsp;&nbsp;<a href="./general/credits.html">Credits</a>
-</p>
-<p><a href="http://www.codeigniter.com">CodeIgniter</a> &nbsp;&middot;&nbsp; Copyright &#169; 2007 &nbsp;&middot;&nbsp; <a href="http://ellislab.com/">Ellislab, Inc.</a></p>
-</div>
-
-</body>
-</html>
\ No newline at end of file
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html><head><title>CodeIgniter User Guide : Change Log</title><style type='text/css' media='all'>@import url('userguide.css');</style><link rel='stylesheet' type='text/css' media='all' href='userguide.css' /><script type="text/javascript" src="./nav/nav.js"></script><script type="text/javascript" src="./nav/prototype.lite.js"></script><script type="text/javascript" src="./nav/moo.fx.js"></script><script type="text/javascript" src="./nav/user_guide_menu.js"></script><meta http-equiv="Content-Type" content="text/html; charset=utf-8" /><meta http-equiv='expires' content='-1' /><meta http-equiv= 'pragma' content='no-cache' /><meta name='robots' content='all' /><meta name='author' content='Rick Ellis' /><meta name='description' content='CodeIgniter User Guide' /></head><body><!-- START NAVIGATION --><div id="nav"><div id="nav_inner"><script type="text/javascript">create_menu('./');</script></div></div><div id="nav2"><a name="top"></a><a href="javascript:void(0);" onclick="myHeight.toggle();"><img src="./images/nav_toggle.jpg" width="153" height="44" border="0" title="Toggle Table of Contents" alt="Toggle Table of Contents" /></a></div><div id="masthead"><table cellpadding="0" cellspacing="0" border="0" style="width:100%"><tr><td><h1>CodeIgniter User Guide Version 1.5.4</h1></td><td id="breadcrumb_right"><a href="./toc.html">Table of Contents Page</a></td></tr></table></div><!-- END NAVIGATION --><!-- START BREADCRUMB --><table cellpadding="0" cellspacing="0" border="0" style="width:100%"><tr><td id="breadcrumb"><a href="http://www.codeigniter.com/">CodeIgniter Home</a> &nbsp;&#8250;&nbsp;<a href="index.html">User Guide Home</a> &nbsp;&#8250;&nbsp;Change Log</td><td id="searchbox"><form method="get" action="http://www.google.com/search"><input type="hidden" name="as_sitesearch" id="as_sitesearch" value="codeigniter.com/user_guide/" />Search User Guide&nbsp; <input type="text" class="input" style="width:200px;" name="q" id="q" size="31" maxlength="255" value="" />&nbsp;<input type="submit" class="submit" name="sa" value="Go" /></form></td></tr></table><!-- END BREADCRUMB --><br clear="all" /><!-- START CONTENT --><div id="content"><h1>Change Log</h1><h2>Version 1.5.5</h2><p>Release Date: -- still in development </p><ul>	<li>Added Flashdata variables, session_id regeneration and configurable session update   times to the <a href="./libraries/sessions.html">Session class.</a></li>	<li>Added the ability to <a href="./general/autoloader.html">auto-load</a> <a href="./general/models.html">Models</a></li>	<li>Added $this->DB->save_queries variable to DB driver, enabling queries to get saved or no. Previously they were always saved.</li>	<li>Added <dfn>$assign_to_controller</dfn> variable in the main <kbd>index.php</kbd> file.  Anything that this variable contains will be passed automatically to a controller constructor when initialized.</li>	<li>Reorganized the URI and Routes classes for better clarity.</li>    <li>Javascript Calendar plugin now uses the months and days from the calendar language file, instead of hard-coded values, internationalizing it.</li>    <li>Removed &quot;rand()&quot; as a listed option from orderby in the <a href="./database/active_record.html">Active Record</a>, as it was MySQL only. </li>    <li>Added titles to all user manual pages.</li>    <li>Added a check for NULL fields in the MySQL database backup utility.</li>    <li>Documented the timezones() function in the <a href="./helpers/date_helper.html">Date Helper</a>.</li>    <li>Documented unset_userdata in the <a href="./libraries/sessions.html">Session class</a>.</li>    <li>Changed the behaviour of custom callbacks so that they no longer trigger the &quot;required&quot; rule. </li>    <li>Added a few additional mime type variations for CSV.</li>    <li>Moved the safe mode and auth checks for the Email library into the constructor </li>    <li>Fixed a bug in the <a href="./libraries/email.html">Email</a> library where some timezones were calculated incorrectly. </li>    <li>Fixed a bug in <a href="./libraries/validation.html">Validation</a> where valid_ip() wasn't called properly.</li>    <li>Fixed a bug in the Session library where user agent matching would fail on user agents ending with a space. </li>    <li>Fixed a bug in database driver where num_rows property wasn't getting updated.</li>    <li>Fixed a bug in captcha calling an invalid PHP function.</li>    <li>Fixed a bug in _html_entity_decode_callback() when 'global_xss_filtering' is enabled.</li>	<li>Fixed a bug in the cookie helper "set_cookie" function.  It was not honoring the config settings.</li>    <li>Fixed an example of comma-separated emails in the email library documentation.</li>    <li>Fixed an example in the Calendar library for Showing Next/Previous Month Links.</li>    <li>Fixed a typo in the database language file. </li>    <li>Fixed a typo in the docblock comments that had CodeIgniter spelled CodeIgnitor. </li>    <li>Fixed a typo in the <a href="./helpers/string_helper.html">String Helper</a> (uniquid changed to uniqid) </li>    <li>Fixed a typo in the DocBlock comment for unset_userdata() in Session.</li>    <li>Moved part of the userguide menu javascript to an external file. </li></ul><h2>Version 1.5.4</h2><p>Release Date: July 12, 2007 </p><ul>    <li>Added <a href="./libraries/language.html">custom Language files</a> to the <a href="./general/autoloader.html">autoload</a> options. </li>	<li>Added stripslashes() to the _clean_input_data() function in the <a href="./libraries/input.html">Input class</a> when magic quotes is on so that data will always be un-slashed within the framework.</li>	<li>Added array to string into the <a href="general/profiling.html">profiler</a>.</li>	<li>Added some additional mime types in application/config/mimes.php.</li>	<li>Added filename_security() method to <a href="./libraries/input.html">Input library</a>.</li>	<li>Added some additional arguments to the <a href="./helpers/inflector_helper.html">Inflection helper</a> singular() to compensate for words ending in "s".  Also added a force parameter to pluralize().</li>	<li>Added $config['charset'] to the config file.  Default value is 'UTF-8', used in some string handling functions.</li>	<li>Fixed MSSQL insert_id().</li>	<li>Fixed a logic error in the DB trans_status() function.  It was incorrectly returning TRUE on failure and FALSE on success.</li>	<li>Fixed a bug that was allowing multiple load attempts on extended classes.</li>	<li>Fixed a bug in the bootstrap file that was incorrectly attempting to discern the full server path even when it was explicity set by the user.</li>	<li>Fixed a bug in the escape_str() function in the MySQL driver.</li>    <li>Fixed a typo in the <a href="./libraries/calendar.html">Calendar library </a> </li>    <li>Fixed a typo in rpcs.php library</li>    <li>Fixed a bug in the <a href="./libraries/zip.html">Zip library</a>, providing PC Zip file compatibility with Mac OS X</li>    <li>Fixed a bug in router that was ignoring the scaffolding route for optimization </li>	<li>Fixed an IP validation bug.</li>	<li>Fixed a bug in display of POST keys in the <a href="./general/profiling.html">Profiler</a> output</li>	<li>Fixed a bug in display of queries with characters that would be interpreted as HTML in the <a href="./general/profiling.html">Profiler</a> output</li>	<li>Fixed a bug in display of Email class print debugger with characters that would be interpreted as HTML in the debugging output</li>	<li>Fixed a bug in the Content-Transfer-Encoding of HTML emails with the quoted-printable MIME type</li>	<li>Fixed a bug where one could unset certain PHP superglobals by setting them via GET or POST data</li>	<li>Fixed an undefined function error in the insert_id() function of the PostgreSQL driver</li>	<li>Fixed various doc typos. </li>	<li>Documented two functions from the <a href="./helpers/string_helper.html">String helper </a> that were missing from the user guide:  trim_slashes() and reduce_double_slashes().</li>	<li>Docs now validate to XHTML 1 transitional</li>    <li>Updated the XSS Filtering to take into account the IE expression() ability and improved certain deletions to prevent possible exploits</li>    <li>Modified the Router so that when Query Strings are Enabled, the controller trigger and function trigger values are sanitized for filename include security.</li>    <li>Modified the is_image() method in the Upload library to take into account Windows IE 6/7 eccentricities when dealing with MIMEs</li>    <li>Modified XSS Cleaning routine to be more performance friendly and compatible with PHP 5.2's new PCRE backtrack and recursion limits.</li>	<li>Modified the <a href="./helpers/url_helper.html">URL Helper</a> to type cast the $title as a string in case a numeric value is supplied</li>	<li>Modified Form Helper form_dropdown() to type cast the keys and values of the options array as strings, allowing numeric values to be properly set as 'selected'</li>	<li>Deprecated the use if <kbd>is_numeric()</kbd> in various places since it allows periods.  Due to compatibility problems with <kbd>ctype_digit()</kbd>, making it unreliable in some installations, the following regular expression was used instead:  <kbd>preg_match("/[^0-9]/", $n)</kbd></li>    <li>Deprecated: APPVER has been deprecated and replaced with CI_VERSION for clarity. </li></ul><h2>Version 1.5.3</h2><p>Release Date: April 15, 2007 </p><ul>    <li>Added array to string into the profiler </li>    <li>Code Igniter references updated to CodeIgniter </li>    <li>pMachine references updated to EllisLab </li>    <li>Fixed a bug in the repeater function of <a href="./helpers/string_helper.html">string helper</a>. </li>    <li>Fixed a bug in ODBC driver </li>    <li>Fixed a bug in result_array() that was returning an empty array when no result is produced.</li>    <li>Fixed a bug in the redirect function of the <a href="./helpers/url_helper.html">url helper</a>. </li>    <li>Fixed an undefined variable in Loader </li>    <li>Fixed a version bug in the Postgre driver </li>    <li>Fixed a bug in the textarea function of the form helper for use with strings</li>    <li>Fixed doc typos. </li></ul><h2>Version 1.5.2</h2><p>Release Date: February 13, 2007 </p><ul>    <li>Added <a href="./installation/downloads.html#svn">subversion information</a> to the <a href="./installation/downloads.html">downloads</a> page. </li>	<li>Added support for captions in the <a href="./libraries/table.html">Table Library</a> </li>	<li>Fixed a bug in the <a href="./helpers/download_helper.html">download_helper</a> that was causing Internet Explorer to load rather then download </li>    <li>Fixed a bug in the Active Record Join function that was not taking table prefixes into consideration.</li>    <li>Removed unescaped variables in error messages of Input and Router classes</li>    <li>Fixed a bug in the Loader that was causing errors on Libraries loaded twice. A debug message is now silently made in the log.  </li>    <li>Fixed a bug in the <a href="./helpers/form_helper.html">form helper</a> that gave textarea a value attribute </li>    <li>Fixed a bug in the <a href="./libraries/image_lib.php">Image Library</a> that was ignoring resizing the same size image </li>    <li>Fixed some doc typos.</li></ul><h2>Version 1.5.1</h2><p>Release Date: November 23, 2006</p><ul>    <li>Added support for submitting arrays of libraries in the $this-&gt;load-&gt;library function.</li>    <li>Added support for naming custom library files in lower or uppercase.</li>    <li>Fixed a bug related to output buffering.</li>    <li>Fixed a bug in the active record class that was not resetting query data after a completed query.</li>    <li>Fixed a bug that was suppressing errors in controllers.</li>    <li>Fixed a problem that can cause a loop to occur when the config file is missing.</li>    <li>Fixed a bug that occurred when multiple models were loaded with the third parameter set to TRUE.</li>    <li>Fixed an oversight that was not unsetting globals properly in the input sanitize function.</li>    <li>Fixed some bugs in the Oracle DB driver.</li>    <li>Fixed an incorrectly named variable in the MySQLi result driver.</li>    <li>Fixed some doc typos.</li></ul><h2>Version 1.5.0.1</h2><p>Release Date: October 31, 2006</p><ul><li>Fixed a problem in which duplicate attempts to load helpers and classes were not being stopped.</li><li>Fixed a bug in the word_wrap() helper function.</li><li>Fixed an invalid color Hex number in the Profiler class.</li><li>Fixed a corrupted image in the user guide.</li></ul><h2>Version 1.5.0</h2><p>Release Date: October 30, 2006</p><ul><li>Added <a href="./database/utilities.html">DB utility class</a>, permitting DB backups, CVS or XML files from DB results, and various other functions.</li><li>Added <a href="./database/caching.html">Database Caching Class</a>.</li><li>Added <a href="./database/transactions.html">transaction support</a> to the database classes.</li><li>Added <a href="./general/profiling.html">Profiler Class</a> which generates a report of Benchmark execution times, queries, and POST data at the bottom of your pages.</li><li>Added <a href="./libraries/user_agent.html">User Agent Library</a> which allows browsers, robots, and mobile devises to be identified.</li><li>Added <a href="./libraries/table.html">HTML Table Class</a> , enabling tables to be generated from arrays or database results.</li><li>Added <a href="./libraries/zip.html">Zip Encoding Library</a>.</li><li>Added <a href="./libraries/ftp.html">FTP Library</a>.</li><li>Added the ability to <a href="./general/creating_libraries.html">extend libraries</a> and <a href="./general/core_classes.html">extend core classes</a>, in addition to being able to replace them.</li><li>Added support for storing <a href="./general/models.html">models within sub-folders</a>.</li><li>Added <a href="./helpers/download_helper.html">Download Helper</a>.</li><li>Added <a href="./database/queries.html">simple_query()</a> function to the database classes</li><li>Added <a href="./helpers/date_helper.html">standard_date()</a> function to the Date Helper.</li><li>Added <a href="./database/results.html">$query->free_result()</a> to database class.</li><li>Added <a href="./database/fields.html">$query->list_fields()</a> function to database class</li><li>Added <a href="./database/helpers.html">$this->db->platform()</a> function</li><li>Added new <a href="./helpers/file_helper.html">File Helper</a>:  get_filenames()</li><li>Added new helper:  <a href="./helpers/smiley_helper.html">Smiley Helper</a></li><li>Added support for &lt;ul> and &lt;ol> lists in the  <a href="./helpers/html_helper.html">HTML Helper</a></li><li>Added the ability to rewrite <a href="./general/alternative_php.html">short tags</a> on-the-fly, converting them to standard PHP statements, for those servers that do not support short tags.  This allows the cleaner syntax to be used regardless of whether it's supported by the server.</li><li>Added the ability to <a href="./general/managing_apps.html">rename or relocate the "application" folder</a>.<li>Added more thorough initialization in the upload class so that all class variables are reset.</li><li>Added "is_numeric" to validation, which uses the native PHP is_numeric function.</li><li>Improved the URI handler to make it more reliable when the $config['uri_protocol'] item is set to AUTO.</li><li>Moved most of the functions in the Controller class into the Loader class, allowing fewer reserved function names for controllers when running under PHP 5.</li><li>Updated the DB Result class to return an empty array when $query->result() doesn't produce a result.</li><li>Updated the <dfn>input->cookie()</dfn> and <dfn>input->post()</dfn> functions in <a href="./libraries/input.html">Input Class</a> to permit arrays contained cookies that are arrays to be run through the XSS filter.</li><li>Documented three functions from the <a href="./libraries/validation.html">Validation class</a> that were missing from the user guide:  set_select(), set_radio(), and set_checkbox().</li><li>Fixed a bug in the Email class related to SMTP Helo data.</li><li>Fixed a bug in the word wrapping helper and function in the email class.</li><li>Fixed a bug in the validation class.</li><li>Fixed a bug in the typography helper that was incorrectly wrapping block level elements in paragraph tags.</li><li>Fixed a problem in the form_prep() function that was double encoding entities.</li><li>Fixed a bug that affects some versions of PHP when output buffering is nested.</li><li>Fixed a bug that caused CI to stop working when the PHP magic __get() or __set() functions were used within models or controllers.</li><li>Fixed a pagination bug that was permitting negative values in the URL.</li><li>Fixed an oversight in which the Loader class was not allowed to be exteneded.</li><li>Changed <dfn>_get_config()</dfn> to <dfn>get_config()</dfn> since the function is not a private one.</li><li><strong>Deprecated "init" folder</strong>.  Initialization happens automatically now.  <a href="./general/creating_libraries.html">Please see documentation</a>.</li><li><strong>Deprecated</strong> $this->db->field_names()  USE  $this->db->list_fields()</li><li><strong>Deprecated</strong> the <dfn>$config['log_errors']</dfn> item from the config.php file.  Instead, <dfn>$config['log_threshold']</dfn> can be set to "0" to turn it off.</li></ul><h2>Version 1.4.1</h2><p>Release Date: September 21, 2006</p><ul><li>Added a new feature that passes URI segments directly to your function calls as parameters. See the <a href="controllers.html">Controllers</a> page for more info.</li><li>Added support for a function named <dfn>_output()</dfn>, which when used in your controllers will received the final rendered output from the output class.  More info in the <a href="controllers.html">Controllers</a> page.</li><li>Added several new functions in the <a href="./libraries/uri.html">URI Class</a> to let you retrieve and manipulate URI segments that have been re-routed using the <a href="routing.html">URI Routing</a> feature. Previously, the URI class did not permit you to access any re-routed URI segments, but now it does.</li><li>Added <a href="./libraries/output.html">$this->output->set_header()</a> function, which allows you to set server headers.</li><li>Updated plugins, helpers, and language classes to allow your <dfn>application</dfn> folder to contain its own plugins, helpers, and language folders.  Previously they were always treated as global for your entire installation.  If your application folder contains any of these resources they will be used <em>instead</em> the global ones.</li><li>Added <a href="./helpers/inflector_helper.html">Inflector helper</a>.</li><li>Added <dfn>element()</dfn> function in the <a href="./helpers/array_helper.html">array helper</a>.</li><li>Added <dfn>RAND()</dfn> to active record <dfn>orderby()</dfn> function.</li><li>Added <dfn>delete_cookie()</dfn> and <dfn>get_cookie()</dfn> to <a href="./helpers/cookie_helper.html">Cookie helper</a>, even though the input class has a cookie fetching function.</li><li>Added Oracle database driver (still undergoing testing so it might have some bugs).</li><li>Added the ability to combine pseudo-variables and php variables in the template parser class.</li><li>Added output compression option to the config file.</li><li>Removed the is_numeric test from the db->escape() function.</li><li>Fixed a MySQLi bug that was causing error messages not to contain proper error data.</li><li>Fixed a bug in the email class which was causing it to ignore explicitly set alternative headers.</li><li>Fixed a bug that was causing a PHP error when the Exceptions class was called within the get_config() function since it was causing problems.</li><li>Fixed an oversight in the cookie helper in which the config file cookie settings were not being honored.</li><li>Fixed an oversight in the upload class. An item mentioned in the 1.4 changelog was missing.</li><li>Added some code to allow email attachments to be reset when sending batches of email.</li><li>Deprecated the <dfn>application/scripts</dfn> folder. It will continue to work for legacy users, but it is recommended that you create your own<a href="./general/libraries.html">libraries</a> or <a href="./general/models.html">models</a> instead.  It was originally added before CI had user libraries or models, but it's not needed anymore.</li><li>Deprecated the <dfn>$autoload['core']</dfn> item from the <kbd>autoload.php</kbd> file.  Instead, please now use: <kbd>$autoload['libraries']</kbd></li><li>Deprecated the following database functions: $this->db->smart_escape_str() and $this->db->fields().</li></ul><h2>Version 1.4.0</h2><p>Release Date: September 17, 2006</p><ul><li>Added <a href="hooks.html">Hooks</a> feature, enabling you to tap into and modify the inner workings of the framework without hacking the core files.</li><li>Added the ability to organize controller files <a href="controllers.html">into sub-folders</a>.  Kudos to Marco for <a href="http://www.codeigniter.com/forums/viewthread/627/">suggesting</a> this (and the next two) feature.</li><li>Added regular expressions support for <a href="routing.html">routing rules</a>.</li><li>Added the ability to <a href="controllers.html">remap function calls</a> within your controllers.</li><li>Added the ability to <a href="core_classes.html">replace core system classes</a> with your own classes.</li><li>Added support for % character in URL.</li><li>Added the ability to supply full URLs using the <a href="./helpers/url_helper.html">anchor()</a> helper function.</li><li>Added mode parameter to <a href="./helpers/file_helper.html">file_write()</a> helper.</li><li>Added support for changing the port number in the <a href="./database/configuration.html">Postgre driver</a>.</li><li>Moved the list of "allowed URI characters" out of the Router class and into the config file.</li><li>Moved the MIME type array out of the Upload class and into its own file in the applications/config/ folder.</li><li>Updated the Upload class to allow the upload field name to be set when calling <a href="./libraries/file_uploading.html">do_upload()</a>.</li><li>Updated the <a href="./libraries/config.html">Config Library</a> to be able to load config files silently, and to be able to assign config files to their own index (to avoid collisions if you use multiple config files).</li><li>Updated the URI Protocol code to allow more options so that URLs will work more reliably in different environments.</li><li>Updated the <dfn>form_open()</dfn> helper to allow the GET method to be used.</li><li>Updated the MySQLi <dfn>execute()</dfn> function with some code to help prevent lost connection errors.</li><li>Updated the SQLite Driver to check for object support before attempting to return results as objects.  If unsupported it returns an array.</li><li>Updated the Models loader function to allow multiple loads of the same model.</li><li>Updated the MS SQL driver so that single quotes are escaped.</li><li>Updated the Postgre and ODBC drivers for better compatibility.</li><li>Removed a strtolower() call that was changing URL segments to lower case.</li><li>Removed some references that were interfering with PHP 4.4.1 compatibility.</li><li>Removed backticks from Postgre class since these are not needed.</li><li>Renamed <dfn>display()</dfn> to <dfn>_display()</dfn> in the Output class to make it clear that it's a private function.</li><li>Deprecated the hash() function due to a naming conflict with a native PHP function with the same name.  Please use <kbd>dohash()</kbd> instead.</li><li>Fixed an bug that was preventing the input class from unsetting GET variables.</li><li>Fixed a router bug that was making it too greedy when matching end segments.</li><li>Fixed a bug that was preventing multiple discreet database calls.</li><li>Fixed a bug in which loading a language file was producing a "file contains no data" message.</li><li>Fixed a session bug caused by the XSS Filtering feature inadvertently changing the case of certain words.</li><li>Fixed some missing prefixes when using the database prefix feature.</li><li>Fixed a typo in the Calendar class (cal_november).</li><li>Fixed a bug in the <dfn>form_checkbox()</dfn> helper.</li><li>Fixed a bug that was allowing the second segment of the URI to be identical to the class name.</li><li>Fixed an evaluation bug in the database initialization function.</li><li>Fixed a minor bug in one of the error messages in the language class.</li><li>Fixed a bug in the date helper <dfn>timespan</dfn> function.</li><li>Fixed an undefined variable in the DB Driver class.</li><li>Fixed a bug in which dollar signs used as binding replacement values in the DB class would be treated as RegEx back-references.</li><li>Fixed a bug in the <dfn>set_hash()</dfn> function which was preventing MD5 from being used.</li><li>Fixed a couple bugs in the Unit Testing class.</li><li>Fixed an incorrectly named variable in the Validation class.</li><li>Fixed an incorrectly named variable in the URI class.</li><li>Fixed a bug in the config class that was preventing the base URL from being called properly.</li><li>Fixed a bug in the validation class that was not permitting callbacks if the form field was empty.</li><li>Fixed a problem that was preventing scaffolding from working properly with MySQLi.</li><li>Fixed some MS SQL bugs.</li><li>Fixed some doc typos.</li></ul><h2>Version 1.3.3</h2><p>Release Date: June 1, 2006</p><ul><li>Models do <strong>not</strong> connect automatically to the database as of this version. <a href="./general/models.html">More info here</a>.</li><li>Updated the Sessions class to utilize the active record class when running session related queries.  Previously the queries assumed MySQL syntax.</li><li>Updated alternator() function to re-initialize when called with no arguments, allowing multiple calls.</li><li>Fixed a bug in the active record "having" function.</li><li>Fixed a problem in the validation class which was making checkboxes be ignored when required.</li><li>Fixed a bug in the word_limiter() helper function.  It was cutting off the fist word.</li><li>Fixed a bug in the xss_clean function due to a PHP bug that affects some versions of html_entity_decode.</li><li>Fixed a validation bug that was preventing rules from being set twice in one controller.</li><li>Fixed a calendar bug that was not letting it use dynamically loaded languages.</li><li>Fixed a bug in the active record class when using WHERE clauses with LIKE</li><li>Fixed a bug in the hash() security helper.</li><li>Fixed some typos.</li></ul><h2>Version 1.3.2</h2><p>Release Date: April 17, 2006</p><ul><li>Changed the behavior of the validation class such that if a "required" rule is NOT explicitly stated for a field then all other tests get ignored.</li><li>Fixed a bug in the Controller class that was causing it to look in the local "init" folder instead of the main system one.</li><li>Fixed a bug in the init_pagination file.  The $config item was not being set correctly.</li><li>Fixed a bug in the auto typography helper that was causing inconsistent behavior.</li><li>Fixed a couple bugs in the Model class.</li><li>Fixed some documentation typos and errata.</li></ul><h2>Version 1.3.1</h2><p>Release Date: April 11, 2006</p><ul><li>Added a <a href="./libraries/unit_testing.html">Unit Testing Library</a>.</li><li>Added the ability to pass objects to the <strong>insert()</strong> and <strong>update()</strong>  database functions.This feature enables you to (among other things) use your  <a href="./general/models.html">Model class</a> variables to run queries with. See the Models page for details.</li><li>Added the ability to pass objects to the <a href="./general/views.html">view loading function</a>: $this->load->view('my_view', <var>$object</var>);</li><li>Added <kbd>getwhere</kbd> function to <a href="./database/active_record.html">Active Record class</a>.</li><li>Added <kbd>count_all</kbd> function to <a href="./database/active_record.html">Active Record class</a>.</li><li>Added language file for scaffolding and fixed a scaffolding bug that occurs when there are no rows in the specified table.</li><li>Added <a href="./database/queries.html">$this->db->last_query()</a>, which allows you to view your last query that was run.</li><li>Added a new mime type to the upload class for better compatibility.</li><li>Changed how cache files are read to prevent PHP errors if the cache file contains an XML tag, which PHP wants to interpret as a short tag.</li><li>Fixed a bug in a couple of the active record functions (where and orderby).</li><li>Fixed a bug in the image library when realpath() returns false.</li><li>Fixed a bug in the Models that was preventing libraries from being used within them.</li><li>Fixed a bug in the "exact_length" function of the validation class.</li><li>Fixed some typos in the user guide</li></ul><h2>Version 1.3</h2><p>Release Date: April 3, 2006</p><ul><li>Added support for <a href="models.html">Models</a>.</li><li>Redesigned the database libraries to support additional RDBMs (Postgre, MySQLi, etc.).</li><li>Redesigned the <a href="./database/active_record.html">Active Record class</a> to enable more varied types of queries with simpler syntax, and advanced features like JOINs.</li><li>Added a feature to the database class that lets you run <a href="./database/call_function.html">custom function calls</a>.</li><li>Added support for <a href="controllers.html">private functions</a> in your controllers.  Any controller function name that starts with an underscore will not be served by a URI request.</li><li>Added the ability to pass your own initialization parameters to your <a href="creating_libraries.html">custom core libraries</a> when using $this->load->library()</li><li>Added support for running standard <a href="urls.html">query string URLs</a>.  These can be optionally enabled in your config file.</li><li>Added the ability to  <a href="urls.html">specify a "suffix"</a>, which will be appended to your URLs.  For example, you could add .html to your URLs, making them appear static. This feature is enabled in your config file.</li><li>Added a new error template for use with native PHP errors.</li><li>Added "alternator" function in the <a href="./helpers/string_helper.html">string helpers</a>.<li>Removed slashing from the input class. After much debate we decided to kill this feature.</li><li>Change the commenting style in the scripts to the PEAR standard so that IDEs and tools like phpDocumenter can harvest the comments.</li><li>Added better class and function name-spacing to avoid collisions with user developed classes. All CodeIgniter classes are now prefixed with <dfn>CI_</dfn> andall controller methods are prefixed with <dfn>_ci</dfn> to avoid controller collisions. A list of reserved function names can be <a href="controllers.html">found here</a>.</li><li>Redesigned how the "CI" super object is referenced, depending on whether PHP 4 or 5 is being run, since PHP 5 allows a more graceful way to manage objects that utilizes a bit less resources.</li><li>Deprecated: <var>$this->db->use_table()</var> has been deprecated. Please read the <a href="./database/active_record.html">Active Record</a> page for information.</li><li>Deprecated: <var>$this->db->smart_escape_str()</var> has been deprecated. Please use this instead: <var>$this->db->escape()</var></li><li>Fixed a bug in the exception handler which was preventing some PHP errors from showing up.</li><li>Fixed a typo in the URI class.  $this->total_segment() should be plural: $this->total_segments()</li><li>Fixed some typos in the default calendar template</li><li>Fixed some typos in the user guide</li></ul><h2>Version 1.2</h2><p>Release Date: March 21, 2006</p><ul><li>Redesigned some internal aspects of the framework to resolve scoping problems that surfaced during the beta tests. The problem was most notable when instantiating classes in your constructors, particularly if those classes in turn did work in their constructors.</li><li>Added a global function named <a href="ancillary_classes.html">get_instance()</a> allowing the main CodeIgniter object to be accessible throughout your own classes.</li><li>Added new <a href="./helpers/file_helper.html">File Helper</a>:  delete_files()</li><li>Added new <a href="./helpers/url_helper.html">URL Helpers</a>:  base_url(), index_page()</li><li>Added the ability to create your own <a href="creating_libraries.html">core libraries</a> and store them in your local application directory.</li><li>Added an <kbd>overwrite</kbd> option to the <a href="./libraries/file_uploading.html">Upload class</a>, enabling files to be overwritten rather than having the file name appended.</li><li>Added Javascript Calendar plugin.</li><li>Added search feature to user guide.  Note: This is done using Google, which at the time of this writing has not crawled all the pages of the docs.</li><li>Updated the parser class so that it allows tag pars within other tag pairs.</li><li>Fixed a bug in the DB "where" function.</li><li>Fixed a bug that was preventing custom config files to be auto-loaded.</li><li>Fixed a bug in the mysql class bind feature that prevented question marks in the replacement data.</li><li>Fixed some bugs in the xss_clean function</li></ul><h2>Version Beta 1.1</h2><p>Release Date: March 10, 2006</p><ul><li>Added a <a href="./libraries/calendar.html">Calendaring class</a>.</li><li>Added support for running <a href="managing_apps.html">multiple applications</a> that share a common CodeIgniter backend.</li><li>Moved the "uri protocol" variable from the index.php file into the config.php file</li><li>Fixed a problem that was preventing certain function calls from working within constructors.</li><li>Fixed a problem that was preventing the $this->load->library function from working in constructors.</li><li>Fixed a bug that occurred when the session class was loaded using the auto-load routine.</li><li>Fixed a bug that can happen with PHP versions that do not support the E_STRICT constant</li><li>Fixed a data type error in the form_radio function (form helper)</li><li>Fixed a bug that was preventing the xss_clean function from being called from the validation class.</li><li>Fixed the cookie related config names, which were incorrectly specified as $conf rather than $config</li><li>Fixed a pagination problem in the scaffolding.</li><li>Fixed a bug in the mysql class "where" function.</li><li>Fixed a regex problem in some code that trimmed duplicate slashes.</li><li>Fixed a bug in the br() function in the HTML helper</li><li>Fixed a syntax mistake in the form_dropdown function in the Form Helper.</li><li>Removed the "style" attributes form the form helpers.</li><li>Updated the documentation. Added "next/previous" links to each page and fixed various typos.</li></ul><h2>Version Beta 1.0 </h2><p>Release Date: February 28, 2006</p><p>First publicly released version.</p></div><!-- END CONTENT --><div id="footer"><p>Previous Topic:&nbsp;&nbsp;<a href="license.html">License Agreement</a>&nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;<a href="#top">Top of Page</a>&nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;<a href="index.html">User Guide Home</a>&nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;Next Topic:&nbsp;&nbsp;<a href="./general/credits.html">Credits</a></p><p><a href="http://www.codeigniter.com">CodeIgniter</a> &nbsp;&middot;&nbsp; Copyright &#169; 2007 &nbsp;&middot;&nbsp; <a href="http://ellislab.com/">Ellislab, Inc.</a></p></div></body></html>
\ No newline at end of file
